diff --git a/lang/cpp26.md b/lang/cpp26.md
index 757033b2fc..11ad849456 100644
--- a/lang/cpp26.md
+++ b/lang/cpp26.md
@@ -575,4 +575,15 @@ C++26とは、2026年中に改訂される予定の、C++バージョンの通
 
 
 ## 取り決め
-- C言語の参照をC17からC23に更新
+- C言語の参照をC17からC23に更新。これにともない、Cライブラリ由来のヘッダに以下の変更が入った
+    - [`<cstdlib>`](/reference/cstdlib.md): [`free_sized()`](/reference/cstdlib/free_sized.md)・[`free_aligned_sized()`](/reference/cstdlib/free_aligned_sized.md)・[`memalignment()`](/reference/cstdlib/memalignment.md)・[`strfromf()`](/reference/cstdlib/strfromf.md)・[`strfromd()`](/reference/cstdlib/strfromd.md)・[`strfroml()`](/reference/cstdlib/strfroml.md)を追加。[`bsearch()`](/reference/cstdlib/bsearch.md)に`const`版オーバーロードを追加。[`realloc()`](/reference/cstdlib/realloc.md)にサイズ`0`を渡した場合がエラー性動作となった
+    - [`<ctime>`](/reference/ctime.md): [`timespec_getres()`](/reference/ctime/timespec_getres.md)・`timegm()`・`gmtime_r()`・`localtime_r()`と、`TIME_MONOTONIC`・`TIME_ACTIVE`・`TIME_THREAD_ACTIVE`・`__STDC_VERSION_TIME_H__`を追加。`asctime()`・`ctime()`を非推奨化
+    - [`<cmath>`](/reference/cmath.md): [`nextup()`](/reference/cmath/nextup.md)・[`nextdown()`](/reference/cmath/nextdown.md)を追加
+    - [`<cstdio>`](/reference/cstdio.md): `_PRINTF_NAN_LEN_MAX`・`__STDC_VERSION_STDIO_H__`を追加
+    - [`<cinttypes>`](/reference/cinttypes.md): 2進数用の書式指定マクロ (`PRIb`*N*・`SCNb`*N*等) と`__STDC_VERSION_INTTYPES_H__`を追加
+    - [`<cfloat>`](/reference/cfloat.md): [`INFINITY`](/reference/cmath/infinity.md)・[`NAN`](/reference/cmath/nan.md)・[`FLT_SNAN`](/reference/cfloat/flt_snan.md)・[`DBL_SNAN`](/reference/cfloat/dbl_snan.md)・[`LDBL_SNAN`](/reference/cfloat/ldbl_snan.md)・`__STDC_VERSION_FLOAT_H__`を追加。[`DECIMAL_DIG`](/reference/cfloat/decimal_dig.md)を非推奨化し、[`FLT_HAS_SUBNORM`](/reference/cfloat/flt_has_subnorm.md)・[`DBL_HAS_SUBNORM`](/reference/cfloat/dbl_has_subnorm.md)・[`LDBL_HAS_SUBNORM`](/reference/cfloat/ldbl_has_subnorm.md)を廃止予定 (obsolescent) とした
+    - [`<climits>`](/reference/climits.md): 各整数型の幅 (ビット数) を表す[`BOOL_WIDTH`](/reference/climits/bool_width.md)等のマクロを追加
+    - [`<cstdint>`](/reference/cstdint.md): 各整数型の幅 (ビット数) を表す[`INT8_WIDTH`](/reference/cstdint/int8_width.md)等のマクロと、`__STDC_VERSION_STDINT_H__`を追加
+    - [`<cstring>`](/reference/cstring.md): `memccpy()`・`strdup()`・`strndup()`・`memset_explicit()`を追加
+    - [`<cuchar>`](/reference/cuchar.md): `mbrtoc8()`・`c8rtomb()`・`__STDC_VERSION_UCHAR_H__`を追加
+    - [`<cstddef>`](/reference/cstddef.md): `unreachable`マクロおよび`__STDC_VERSION_STDDEF_H__`は定義しないことを明記
diff --git a/reference.md b/reference.md
index 5f23c27ed0..21807e4ace 100644
--- a/reference.md
+++ b/reference.md
@@ -225,7 +225,7 @@
 | [`<cerrno>`](/reference/cerrno.md)   | エラー番号                          |                |
 | [`<cfenv>`](/reference/cfenv.md)     | 浮動小数点環境へのアクセス          | C++11 (C99)    |
 | [`<cfloat>`](/reference/cfloat.md)   | 浮動小数点数の定数                  |                |
-| `<cinttypes>`                        | 固定精度整数のための書式指定マクロ  | C++11 (C99)    |
+| [`<cinttypes>`](/reference/cinttypes.md) | 固定精度整数のための書式指定マクロ  | C++11 (C99)    |
 | `<ciso646>`                          | `&&`に対する別名`and`のような、各種演算子に対するマクロを定義する。<br/> ただしC++ではこれらの別名はキーワードとして定義されるため、このヘッダでは何も定義されない。 | C++20で削除               |
 | [`<climits>`](/reference/climits.md) | 整数型の最小値、最大値を表すマクロ  |                |
 | [`<clocale>`](/reference/clocale.md) | ロケール                            |                |
@@ -244,7 +244,7 @@
 | [`<cstring>`](/reference/cstring.md) | 文字列操作                          |                |
 | `<ctgmath>`                          | ジェネリックな数学関数              | C++11 (C99)<br/> C++17で非推奨<br/> C++20で削除 |
 | [`<ctime>`](/reference/ctime.md)     | 日付・時間                          |                |
-| `<cuchar>`                           | ユニコード文字型                    | C++11 (C11)    |
+| [`<cuchar>`](/reference/cuchar.md)   | ユニコード文字型                    | C++11 (C11)    |
 | `<cwchar>`                           | ワイド文字型                        |                |
 | `<cwctype>`                          | ワイド文字の種別と判定              |                |
 
diff --git a/reference/cfloat.md b/reference/cfloat.md
index 7a93ec5767..ef29879a6d 100644
--- a/reference/cfloat.md
+++ b/reference/cfloat.md
@@ -57,7 +57,7 @@ NaN とは非数（Not-a-Number）を表し、ほとんど全ての演算で浮
 | [`FLT_DECIMAL_DIG`](cfloat/flt_decimal_dig.md)  | `float`の数値を10進数で正確に表すのに必要な有効数字の桁数。<br/>上記モデルでは、$b$ が $10$ の累乗の場合、$p \log_{10} b$、それ以外の場合、$\lceil 1 + p \log_{10} b\rceil$ | C++17 |
 | [`DBL_DECIMAL_DIG`](cfloat/dbl_decimal_dig.md)  | `double`の数値を10進数で正確に表すのに必要な有効数字の桁数。<br/>上記モデルでは、$b$ が $10$ の累乗の場合、$p \log_{10} b$、それ以外の場合、$\lceil 1 + p \log_{10} b\rceil$ | C++17 |
 | [`LDBL_DECIMAL_DIG`](cfloat/ldbl_decimal_dig.md) | `long double`の数値を10進数で正確に表すのに必要な有効数字の桁数。<br/>上記モデルでは、$b$ が $10$ の累乗の場合、$p \log_{10} b$、それ以外の場合、$\lceil 1 + p \log_{10} b\rceil$ | C++17 |
-| [`DECIMAL_DIG`](cfloat/decimal_dig.md)          | 精度が一番高い浮動小数点型の数値を10進数で正確に表すのに必要な有効数字の桁数。<br/>上記モデルでは、$p_{\rm max}$ を精度が一番高い浮動小数点型の $p$ とすると、$b$ が $10$ の累乗の場合、$p_{\rm max} \log_{10} b$、それ以外の場合、$\lceil 1 + p_{\rm max}\log_{10} b\rceil$ | C++11 |
+| [`DECIMAL_DIG`](cfloat/decimal_dig.md)          | 精度が一番高い浮動小数点型の数値を10進数で正確に表すのに必要な有効数字の桁数。<br/>上記モデルでは、$p_{\rm max}$ を精度が一番高い浮動小数点型の $p$ とすると、$b$ が $10$ の累乗の場合、$p_{\rm max} \log_{10} b$、それ以外の場合、$\lceil 1 + p_{\rm max}\log_{10} b\rceil$ | C++11<br/> C++26で非推奨 |
 | [`FLT_MANT_DIG`](cfloat/flt_mant_dig.md)        | `float`を基数 [`FLT_RADIX`](cfloat/flt_radix.md) で表現した際の仮数部の桁数。<br/>上記モデルでは、$p$ | |
 | [`DBL_MANT_DIG`](cfloat/dbl_mant_dig.md)        | `double`を基数 [`FLT_RADIX`](cfloat/flt_radix.md) で表現した際の仮数部の桁数。<br/>上記モデルでは、$p$ | |
 | [`LDBL_MANT_DIG`](cfloat/ldbl_mant_dig.md)      | `long double`を基数 [`FLT_RADIX`](cfloat/flt_radix.md) で表現した際の仮数部の桁数。<br/>上記モデルでは、$p$ | |
@@ -76,9 +76,27 @@ NaN とは非数（Not-a-Number）を表し、ほとんど全ての演算で浮
 
 | マクロ | 説明 | 対応バージョン |
 |--------|------|----------------|
-| [`FLT_HAS_SUBNORM`](cfloat/flt_has_subnorm.md)   | `float`における非正規化数のサポート状況を判定する | C++17 |
-| [`DBL_HAS_SUBNORM`](cfloat/dbl_has_subnorm.md)   | `double`における非正規化数のサポート状況を判定する | C++17 |
-| [`LDBL_HAS_SUBNORM`](cfloat/ldbl_has_subnorm.md) | `long double`における非正規化数のサポート状況を判定する | C++17 |
+| [`FLT_HAS_SUBNORM`](cfloat/flt_has_subnorm.md)   | `float`における非正規化数のサポート状況を判定する | C++17<br/> C++26で非推奨 |
+| [`DBL_HAS_SUBNORM`](cfloat/dbl_has_subnorm.md)   | `double`における非正規化数のサポート状況を判定する | C++17<br/> C++26で非推奨 |
+| [`LDBL_HAS_SUBNORM`](cfloat/ldbl_has_subnorm.md) | `long double`における非正規化数のサポート状況を判定する | C++17<br/> C++26で非推奨 |
+
+
+## 無限大とNaN
+
+| マクロ | 説明 | 対応バージョン |
+|--------|------|----------------|
+| [`INFINITY`](/reference/cmath/infinity.md) | `float`型の正の無限大 | C++26で`<cfloat>`に追加 |
+| [`NAN`](/reference/cmath/nan.md) | `float`型のquiet NaN | C++26で`<cfloat>`に追加 |
+| [`FLT_SNAN`](cfloat/flt_snan.md) | `float`型のシグナルNaN | C++26 |
+| [`DBL_SNAN`](cfloat/dbl_snan.md) | `double`型のシグナルNaN | C++26 |
+| [`LDBL_SNAN`](cfloat/ldbl_snan.md) | `long double`型のシグナルNaN | C++26 |
+
+
+## バージョン情報
+
+| マクロ | 説明 | 対応バージョン |
+|--------|------|----------------|
+| `__STDC_VERSION_FLOAT_H__` | `<cfloat>`が提供するC標準ライブラリ機能のバージョン (`202311L`) | C++26 |
 
 
 ## 最大値
@@ -117,3 +135,5 @@ NaN とは非数（Not-a-Number）を表し、ほとんど全ての演算で浮
 ## 参照
 - [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を参照するようになり、`INFINITY`・`NAN`・`FLT_SNAN`・`DBL_SNAN`・`LDBL_SNAN`・`__STDC_VERSION_FLOAT_H__`が追加された。`DECIMAL_DIG`が非推奨となり、`FLT_HAS_SUBNORM`・`DBL_HAS_SUBNORM`・`LDBL_HAS_SUBNORM`が廃止予定 (obsolescent) となった
diff --git a/reference/cfloat/dbl_has_subnorm.md b/reference/cfloat/dbl_has_subnorm.md
index 5f6b13c269..90038be2ea 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) となった
diff --git a/reference/cfloat/dbl_snan.md b/reference/cfloat/dbl_snan.md
new file mode 100644
index 0000000000..bc59c1267b
--- /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>`に追加された
diff --git a/reference/cfloat/decimal_dig.md b/reference/cfloat/decimal_dig.md
index ab376685fe..b9af3ed43f 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を参照するようになり、このマクロが非推奨となった
diff --git a/reference/cfloat/flt_has_subnorm.md b/reference/cfloat/flt_has_subnorm.md
index bdf471dd3c..27ba310a9b 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) となった
diff --git a/reference/cfloat/flt_snan.md b/reference/cfloat/flt_snan.md
new file mode 100644
index 0000000000..fb10a15892
--- /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>`に追加された
diff --git a/reference/cfloat/ldbl_has_subnorm.md b/reference/cfloat/ldbl_has_subnorm.md
index f837b06943..c71f9de5d0 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) となった
diff --git a/reference/cfloat/ldbl_snan.md b/reference/cfloat/ldbl_snan.md
new file mode 100644
index 0000000000..0fbddf481c
--- /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>`に追加された
diff --git a/reference/chrono/system_clock.md b/reference/chrono/system_clock.md
index ec323b9c0b..678c68e3bb 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]
 
 ### 出力例
 ```
diff --git a/reference/chrono/system_clock/from_time_t.md b/reference/chrono/system_clock/from_time_t.md
index 9eba06e096..c745e871a5 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]
 
 ### 出力例
 ```
diff --git a/reference/chrono/system_clock/now.md b/reference/chrono/system_clock/now.md
index fa896060da..5645fe1345 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]
 
 ### 出力例
 ```
diff --git a/reference/chrono/system_clock/to_time_t.md b/reference/chrono/system_clock/to_time_t.md
index e8714711fe..f2f0968cb0 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]
 
 ### 出力例
 ```
diff --git a/reference/cinttypes.md b/reference/cinttypes.md
new file mode 100644
index 0000000000..3b8b091b37
--- /dev/null
+++ b/reference/cinttypes.md
@@ -0,0 +1,75 @@
+# cinttypes
+* cinttypes[meta header]
+* cpp11[meta cpp]
+
+`<cinttypes>`ヘッダでは、[`<cstdint>`](cstdint.md)の固定幅整数型を[`<cstdio>`](cstdio.md)の`printf`系・`scanf`系関数で入出力するための書式指定マクロと、最大幅整数型に対する数値変換関数を提供する。これらの機能は、`std`名前空間に属することを除いてC言語の標準ライブラリ`<inttypes.h>`ヘッダと同じである。
+
+このヘッダは[`<cstdint>`](cstdint.md)をインクルードする。
+
+
+## 型
+
+| 名前 | 説明 | 対応バージョン |
+|------|------|----------------|
+| `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*](cinttypes/prib.md) | `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*](cinttypes/scnb.md) | `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
+
+
+## 関連項目
+- [`<cstdint>`](cstdint.md)
+- [`<cstdio>`](cstdio.md)
+
+
+## 参照
+- [N1568 Proposed additions to TR-1 to improve compatibility with C99](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1568.htm)
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、2進数用の書式指定マクロ (`PRIb`*N*・`PRIB`*N*・`SCNb`*N*等) と`__STDC_VERSION_INTTYPES_H__`が追加された
diff --git a/reference/cinttypes/prib.md b/reference/cinttypes/prib.md
new file mode 100644
index 0000000000..f597f18027
--- /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>`に追加された
diff --git a/reference/cinttypes/scnb.md b/reference/cinttypes/scnb.md
new file mode 100644
index 0000000000..d568dbef76
--- /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>`に追加された
diff --git a/reference/climits.md b/reference/climits.md
index a09c191402..4af37594fd 100644
--- a/reference/climits.md
+++ b/reference/climits.md
@@ -34,9 +34,34 @@
 | [`LLONG_MAX`](climits/llong_max.md)   | `long long` の最大値 | C++11 |
 
 
+## 幅
+
+| 名前 | 説明 | 対応バージョン |
+|---------------------------------------|------------------------------------|-------|
+| [`BOOL_WIDTH`](climits/bool_width.md)     | `bool` の幅 (値ビット数)              | C++26 |
+| [`CHAR_WIDTH`](climits/char_width.md)     | `char` の幅 (値ビット数)             | C++26 |
+| [`SCHAR_WIDTH`](climits/schar_width.md)   | `signed char` の幅 (値ビット数)      | C++26 |
+| [`UCHAR_WIDTH`](climits/uchar_width.md)   | `unsigned char` の幅 (値ビット数)    | C++26 |
+| [`SHRT_WIDTH`](climits/shrt_width.md)     | `short` の幅 (値ビット数)            | C++26 |
+| [`USHRT_WIDTH`](climits/ushrt_width.md)   | `unsigned short` の幅 (値ビット数)   | C++26 |
+| [`INT_WIDTH`](climits/int_width.md)       | `int` の幅 (値ビット数)              | C++26 |
+| [`UINT_WIDTH`](climits/uint_width.md)     | `unsigned int` の幅 (値ビット数)     | C++26 |
+| [`LONG_WIDTH`](climits/long_width.md)     | `long` の幅 (値ビット数)             | C++26 |
+| [`ULONG_WIDTH`](climits/ulong_width.md)   | `unsigned long` の幅 (値ビット数)    | C++26 |
+| [`LLONG_WIDTH`](climits/llong_width.md)   | `long long` の幅 (値ビット数)        | C++26 |
+| [`ULLONG_WIDTH`](climits/ullong_width.md) | `unsigned long long` の幅 (値ビット数) | C++26 |
+
+
 ## その他
 
 | 名前 | 説明 | 対応バージョン |
 |-----------------------------------------|----------------------------|-------|
 | [`CHAR_BIT`](climits/char_bit.md)     | 1バイトのビット数          | |
 | [`MB_LEN_MAX`](climits/mb_len_max.md) | マルチバイト文字のバイト数 | |
+
+なお、ビット精度整数型の最大幅を表す`BITINT_MAXWIDTH`は、C++では定義されない。
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、各整数型の幅を表すマクロが追加された
diff --git a/reference/climits/bool_width.md b/reference/climits/bool_width.md
new file mode 100644
index 0000000000..9b807bd9bd
--- /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>`に追加された
diff --git a/reference/climits/char_width.md b/reference/climits/char_width.md
new file mode 100644
index 0000000000..c0da816033
--- /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>`に追加された
diff --git a/reference/climits/int_width.md b/reference/climits/int_width.md
new file mode 100644
index 0000000000..fb10974315
--- /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>`に追加された
diff --git a/reference/climits/llong_width.md b/reference/climits/llong_width.md
new file mode 100644
index 0000000000..7341b0dbfe
--- /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>`に追加された
diff --git a/reference/climits/long_width.md b/reference/climits/long_width.md
new file mode 100644
index 0000000000..19b63daf06
--- /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>`に追加された
diff --git a/reference/climits/schar_width.md b/reference/climits/schar_width.md
new file mode 100644
index 0000000000..f61d414879
--- /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>`に追加された
diff --git a/reference/climits/shrt_width.md b/reference/climits/shrt_width.md
new file mode 100644
index 0000000000..19810ed89a
--- /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>`に追加された
diff --git a/reference/climits/uchar_width.md b/reference/climits/uchar_width.md
new file mode 100644
index 0000000000..88fb3a72d2
--- /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>`に追加された
diff --git a/reference/climits/uint_width.md b/reference/climits/uint_width.md
new file mode 100644
index 0000000000..a4d641768d
--- /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>`に追加された
diff --git a/reference/climits/ullong_width.md b/reference/climits/ullong_width.md
new file mode 100644
index 0000000000..beac60d959
--- /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>`に追加された
diff --git a/reference/climits/ulong_width.md b/reference/climits/ulong_width.md
new file mode 100644
index 0000000000..0e51861394
--- /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>`に追加された
diff --git a/reference/climits/ushrt_width.md b/reference/climits/ushrt_width.md
new file mode 100644
index 0000000000..5a8b42c9a2
--- /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>`に追加された
diff --git a/reference/cmath.md b/reference/cmath.md
index 8c440287f6..d4df95c006 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>
diff --git a/reference/cmath/infinity.md b/reference/cmath/infinity.md
index 56f223c8a5..c868f8e207 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)でも定義されるようになった
diff --git a/reference/cmath/nan.md b/reference/cmath/nan.md
index c623e65f3f..5890678eec 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)でも定義されるようになった
diff --git a/reference/cmath/nextafter.md b/reference/cmath/nextafter.md
index 8a5647008f..7af0bbfb07 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`対応
diff --git a/reference/cmath/nextdown.md b/reference/cmath/nextdown.md
new file mode 100644
index 0000000000..14d88a015d
--- /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>`に追加された
diff --git a/reference/cmath/nextup.md b/reference/cmath/nextup.md
new file mode 100644
index 0000000000..80fa0ff1eb
--- /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>`に追加された
diff --git a/reference/cstddef.md b/reference/cstddef.md
index d67a04642e..9e2c905531 100644
--- a/reference/cstddef.md
+++ b/reference/cstddef.md
@@ -31,3 +31,13 @@
 
 
 C言語においては、このヘッダは`wchar_t`型（ワイド文字型）の宣言もインクルードする。C++において`wchar_t`型は組み込み型であるため、いかなるヘッダもインクルードする必要がない。
+
+
+## 備考
+- C23の`<stddef.h>`が定義する`unreachable`マクロは、`<cstddef>`では定義されない。C++では[`std::unreachable()`](/reference/utility/unreachable.md)を使用する
+- C23の`<stddef.h>`が定義するバージョンマクロ`__STDC_VERSION_STDDEF_H__`は、`<cstddef>`では意図的に定義されない
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになった際、`<cstddef>`では`unreachable`マクロおよび`__STDC_VERSION_STDDEF_H__`を定義しないことが明記された
diff --git a/reference/cstdint.md b/reference/cstdint.md
index f10abe212f..78396a60fc 100644
--- a/reference/cstdint.md
+++ b/reference/cstdint.md
@@ -109,6 +109,54 @@
 | [`SIZE_MAX`](cstdint/size_max.md)                 | [`size_t`](/reference/cstddef/size_t.md)の最大値 | C++11 |
 
 
+## 幅マクロ
+
+以下のマクロは、各整数型の幅 (値ビット数) を表す。
+
+| マクロ | 説明 | 対応バージョン |
+|-------------------------------------------------------|-----------------------|-------|
+| [`INT8_WIDTH`](cstdint/int8_width.md)                 | `int8_t`の幅(実装するかどうかは処理系定義) | C++26 |
+| [`INT16_WIDTH`](cstdint/int16_width.md)               | `int16_t`の幅(実装するかどうかは処理系定義) | C++26 |
+| [`INT32_WIDTH`](cstdint/int32_width.md)               | `int32_t`の幅(実装するかどうかは処理系定義) | C++26 |
+| [`INT64_WIDTH`](cstdint/int64_width.md)               | `int64_t`の幅(実装するかどうかは処理系定義) | C++26 |
+| [`UINT8_WIDTH`](cstdint/uint8_width.md)               | `uint8_t`の幅(実装するかどうかは処理系定義) | C++26 |
+| [`UINT16_WIDTH`](cstdint/uint16_width.md)             | `uint16_t`の幅(実装するかどうかは処理系定義) | C++26 |
+| [`UINT32_WIDTH`](cstdint/uint32_width.md)             | `uint32_t`の幅(実装するかどうかは処理系定義) | C++26 |
+| [`UINT64_WIDTH`](cstdint/uint64_width.md)             | `uint64_t`の幅(実装するかどうかは処理系定義) | C++26 |
+| [`INT_FAST8_WIDTH`](cstdint/int_fast8_width.md)       | `int_fast8_t`の幅 | C++26 |
+| [`INT_FAST16_WIDTH`](cstdint/int_fast16_width.md)     | `int_fast16_t`の幅 | C++26 |
+| [`INT_FAST32_WIDTH`](cstdint/int_fast32_width.md)     | `int_fast32_t`の幅 | C++26 |
+| [`INT_FAST64_WIDTH`](cstdint/int_fast64_width.md)     | `int_fast64_t`の幅 | C++26 |
+| [`UINT_FAST8_WIDTH`](cstdint/uint_fast8_width.md)     | `uint_fast8_t`の幅 | C++26 |
+| [`UINT_FAST16_WIDTH`](cstdint/uint_fast16_width.md)   | `uint_fast16_t`の幅 | C++26 |
+| [`UINT_FAST32_WIDTH`](cstdint/uint_fast32_width.md)   | `uint_fast32_t`の幅 | C++26 |
+| [`UINT_FAST64_WIDTH`](cstdint/uint_fast64_width.md)   | `uint_fast64_t`の幅 | C++26 |
+| [`INT_LEAST8_WIDTH`](cstdint/int_least8_width.md)     | `int_least8_t`の幅 | C++26 |
+| [`INT_LEAST16_WIDTH`](cstdint/int_least16_width.md)   | `int_least16_t`の幅 | C++26 |
+| [`INT_LEAST32_WIDTH`](cstdint/int_least32_width.md)   | `int_least32_t`の幅 | C++26 |
+| [`INT_LEAST64_WIDTH`](cstdint/int_least64_width.md)   | `int_least64_t`の幅 | C++26 |
+| [`UINT_LEAST8_WIDTH`](cstdint/uint_least8_width.md)   | `uint_least8_t`の幅 | C++26 |
+| [`UINT_LEAST16_WIDTH`](cstdint/uint_least16_width.md) | `uint_least16_t`の幅 | C++26 |
+| [`UINT_LEAST32_WIDTH`](cstdint/uint_least32_width.md) | `uint_least32_t`の幅 | C++26 |
+| [`UINT_LEAST64_WIDTH`](cstdint/uint_least64_width.md) | `uint_least64_t`の幅 | C++26 |
+| [`INTMAX_WIDTH`](cstdint/intmax_width.md)             | `intmax_t`の幅 | C++26 |
+| [`UINTMAX_WIDTH`](cstdint/uintmax_width.md)           | `uintmax_t`の幅 | C++26 |
+| [`INTPTR_WIDTH`](cstdint/intptr_width.md)             | `intptr_t`の幅(実装するかどうかは処理系定義) | C++26 |
+| [`UINTPTR_WIDTH`](cstdint/uintptr_width.md)           | `uintptr_t`の幅(実装するかどうかは処理系定義) | C++26 |
+| [`PTRDIFF_WIDTH`](cstdint/ptrdiff_width.md)           | [`ptrdiff_t`](/reference/cstddef/ptrdiff_t.md)の幅 | C++26 |
+| [`SIZE_WIDTH`](cstdint/size_width.md)                 | [`size_t`](/reference/cstddef/size_t.md)の幅 | C++26 |
+| [`SIG_ATOMIC_WIDTH`](cstdint/sig_atomic_width.md)     | `sig_atomic_t`の幅 | C++26 |
+| [`WCHAR_WIDTH`](cstdint/wchar_width.md)               | `wchar_t`の幅 | C++26 |
+| [`WINT_WIDTH`](cstdint/wint_width.md)                 | `wint_t`の幅 | C++26 |
+
+
+## バージョン情報マクロ
+
+| マクロ | 説明 | 対応バージョン |
+|--------|------|----------------|
+| `__STDC_VERSION_STDINT_H__` | `<cstdint>`が提供するC標準ライブラリ機能のバージョン (`202311L`) | C++26 |
+
+
 ## 符号付き整数型用の定数値マクロ
 
 以下のマクロは、各整数型の定数値を表す関数マクロである。  
@@ -159,3 +207,5 @@ C99 の 7.18.3 `<stdint.h>` についての脚注で、同ヘッダを C++ で
 ## 参照
 - [N1568 Proposed additions to TR-1 to improve compatibility with C99](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1568.htm)
 - [N1835 `<stdint.h>` for C++](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1835.pdf)
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、各整数型の幅を表すマクロと`__STDC_VERSION_STDINT_H__`が追加された
diff --git a/reference/cstdint/int16_width.md b/reference/cstdint/int16_width.md
new file mode 100644
index 0000000000..32a06ceece
--- /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>`に追加された
diff --git a/reference/cstdint/int32_width.md b/reference/cstdint/int32_width.md
new file mode 100644
index 0000000000..063be7d285
--- /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>`に追加された
diff --git a/reference/cstdint/int64_width.md b/reference/cstdint/int64_width.md
new file mode 100644
index 0000000000..f23fc651af
--- /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>`に追加された
diff --git a/reference/cstdint/int8_width.md b/reference/cstdint/int8_width.md
new file mode 100644
index 0000000000..dc59d16e9d
--- /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>`に追加された
diff --git a/reference/cstdint/int_fast16_width.md b/reference/cstdint/int_fast16_width.md
new file mode 100644
index 0000000000..44b52c9c4f
--- /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>`に追加された
diff --git a/reference/cstdint/int_fast32_width.md b/reference/cstdint/int_fast32_width.md
new file mode 100644
index 0000000000..838349355e
--- /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>`に追加された
diff --git a/reference/cstdint/int_fast64_width.md b/reference/cstdint/int_fast64_width.md
new file mode 100644
index 0000000000..f318934523
--- /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>`に追加された
diff --git a/reference/cstdint/int_fast8_width.md b/reference/cstdint/int_fast8_width.md
new file mode 100644
index 0000000000..ce16a382d3
--- /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>`に追加された
diff --git a/reference/cstdint/int_least16_width.md b/reference/cstdint/int_least16_width.md
new file mode 100644
index 0000000000..9e5de3ed17
--- /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>`に追加された
diff --git a/reference/cstdint/int_least32_width.md b/reference/cstdint/int_least32_width.md
new file mode 100644
index 0000000000..1d0684b84f
--- /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>`に追加された
diff --git a/reference/cstdint/int_least64_width.md b/reference/cstdint/int_least64_width.md
new file mode 100644
index 0000000000..5de8d3e195
--- /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>`に追加された
diff --git a/reference/cstdint/int_least8_width.md b/reference/cstdint/int_least8_width.md
new file mode 100644
index 0000000000..bfc63a84e1
--- /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>`に追加された
diff --git a/reference/cstdint/intmax_width.md b/reference/cstdint/intmax_width.md
new file mode 100644
index 0000000000..a915baa24e
--- /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>`に追加された
diff --git a/reference/cstdint/intptr_width.md b/reference/cstdint/intptr_width.md
new file mode 100644
index 0000000000..1b41d1ac27
--- /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>`に追加された
diff --git a/reference/cstdint/ptrdiff_width.md b/reference/cstdint/ptrdiff_width.md
new file mode 100644
index 0000000000..9a07303d80
--- /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>`に追加された
diff --git a/reference/cstdint/sig_atomic_width.md b/reference/cstdint/sig_atomic_width.md
new file mode 100644
index 0000000000..f2d3d17499
--- /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>`に追加された
diff --git a/reference/cstdint/size_width.md b/reference/cstdint/size_width.md
new file mode 100644
index 0000000000..b61127fb84
--- /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>`に追加された
diff --git a/reference/cstdint/uint16_width.md b/reference/cstdint/uint16_width.md
new file mode 100644
index 0000000000..8c491beafb
--- /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>`に追加された
diff --git a/reference/cstdint/uint32_width.md b/reference/cstdint/uint32_width.md
new file mode 100644
index 0000000000..1642cdd053
--- /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>`に追加された
diff --git a/reference/cstdint/uint64_width.md b/reference/cstdint/uint64_width.md
new file mode 100644
index 0000000000..35444eaf83
--- /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>`に追加された
diff --git a/reference/cstdint/uint8_width.md b/reference/cstdint/uint8_width.md
new file mode 100644
index 0000000000..da758dd7fa
--- /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>`に追加された
diff --git a/reference/cstdint/uint_fast16_width.md b/reference/cstdint/uint_fast16_width.md
new file mode 100644
index 0000000000..23a52fa2f9
--- /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>`に追加された
diff --git a/reference/cstdint/uint_fast32_width.md b/reference/cstdint/uint_fast32_width.md
new file mode 100644
index 0000000000..f5e36f756b
--- /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>`に追加された
diff --git a/reference/cstdint/uint_fast64_width.md b/reference/cstdint/uint_fast64_width.md
new file mode 100644
index 0000000000..5c41f0093f
--- /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>`に追加された
diff --git a/reference/cstdint/uint_fast8_width.md b/reference/cstdint/uint_fast8_width.md
new file mode 100644
index 0000000000..2989a7e7cb
--- /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>`に追加された
diff --git a/reference/cstdint/uint_least16_width.md b/reference/cstdint/uint_least16_width.md
new file mode 100644
index 0000000000..781a9e3521
--- /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>`に追加された
diff --git a/reference/cstdint/uint_least32_width.md b/reference/cstdint/uint_least32_width.md
new file mode 100644
index 0000000000..ab2527ccc0
--- /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>`に追加された
diff --git a/reference/cstdint/uint_least64_width.md b/reference/cstdint/uint_least64_width.md
new file mode 100644
index 0000000000..45b90d3f4c
--- /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>`に追加された
diff --git a/reference/cstdint/uint_least8_width.md b/reference/cstdint/uint_least8_width.md
new file mode 100644
index 0000000000..2a52d809ff
--- /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>`に追加された
diff --git a/reference/cstdint/uintmax_width.md b/reference/cstdint/uintmax_width.md
new file mode 100644
index 0000000000..b141bfedae
--- /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>`に追加された
diff --git a/reference/cstdint/uintptr_width.md b/reference/cstdint/uintptr_width.md
new file mode 100644
index 0000000000..c61c211bd4
--- /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>`に追加された
diff --git a/reference/cstdint/wchar_width.md b/reference/cstdint/wchar_width.md
new file mode 100644
index 0000000000..1ecdabb4ce
--- /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>`に追加された
diff --git a/reference/cstdint/wint_width.md b/reference/cstdint/wint_width.md
new file mode 100644
index 0000000000..dede07a7bb
--- /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>`に追加された
diff --git a/reference/cstdio.md b/reference/cstdio.md
index ec93b5362c..db7ced487b 100644
--- a/reference/cstdio.md
+++ b/reference/cstdio.md
@@ -30,9 +30,11 @@
 | [`SEEK_CUR`](/reference/cstdio/seek_cur.md.nolink) | ファイルの現在位置を指定するための整数定数 | |
 | [`SEEK_END`](/reference/cstdio/seek_end.md.nolink) | ファイルの終端を指定するための整数定数 | |
 | [`TMP_MAX`](/reference/cstdio/tmp_max.md.nolink)  | `tmpnam()`関数によって生成できる一時ファイル名の、実装が保証する最低限の数を表す整数定数 | |
+| [`_PRINTF_NAN_LEN_MAX`](/reference/cstdio/printf_nan_len_max.md) | `printf`系関数がNaNを出力する際の最大文字数を表す整数定数 | C++26 |
 | [`stderr`](/reference/cstdio/stderr.md)   | 標準エラーを表す`FILE*`型の式 |
 | [`stdin`](/reference/cstdio/stdin.md)    | 標準入力を表す`FILE*`型の式 |
 | [`stdout`](/reference/cstdio/stdout.md)   | 標準出力を表す`FILE*`型の式 |
+| `__STDC_VERSION_STDIO_H__` | `<cstdio>`が提供するC標準ライブラリ機能のバージョン (`202311L`) | C++26 |
 
 
 ## ファイル操作
@@ -106,3 +108,5 @@
 ## 参照
 - [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を参照するようになり、`_PRINTF_NAN_LEN_MAX`と`__STDC_VERSION_STDIO_H__`が追加された
diff --git a/reference/cstdio/printf_nan_len_max.md b/reference/cstdio/printf_nan_len_max.md
new file mode 100644
index 0000000000..a552ef067a
--- /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>`に追加された
diff --git a/reference/cstdlib.md b/reference/cstdlib.md
index a7af4c914f..0f2cb58c54 100644
--- a/reference/cstdlib.md
+++ b/reference/cstdlib.md
@@ -24,6 +24,9 @@
 | `strtof`   | 文字列を、`float`型に変換する (function) | |
 | `strtod`   | 文字列を、`double`型に変換する (function) | |
 | `strtold`  | 文字列を、`long double`型に変換する (function) | C++11 |
+| [`strfromf`](cstdlib/strfromf.md) | `float`型を文字列に変換する (function) | C++26 |
+| [`strfromd`](cstdlib/strfromd.md) | `double`型を文字列に変換する (function) | C++26 |
+| [`strfroml`](cstdlib/strfroml.md) | `long double`型を文字列に変換する (function) | C++26 |
 
 
 ## 擬似乱数
@@ -44,6 +47,9 @@
 | [`calloc`](cstdlib/calloc.md) | メモリを確保し、領域をゼロ初期化する (function) | |
 | [`realloc`](cstdlib/realloc.md) | メモリを再確保する (function) | |
 | [`free`](cstdlib/free.md)    | 確保したメモリを解放する (function) | |
+| [`free_sized`](cstdlib/free_sized.md) | 確保時のサイズを指定して、確保したメモリを解放する (function) | C++26 |
+| [`free_aligned_sized`](cstdlib/free_aligned_sized.md) | アライメントと確保時のサイズを指定して、確保したメモリを解放する (function) | C++26 |
+| [`memalignment`](cstdlib/memalignment.md) | ポインタのアライメントを取得する (function) | C++26 |
 
 
 ## プログラムの開始と終了
@@ -72,7 +78,7 @@
 
 | 名前 | 説明 | 対応バージョン |
 |------|------|----------------|
-| `bsearch` | 二分探索を行う (function) | |
+| [`bsearch`](cstdlib/bsearch.md) | 二分探索を行う (function) | C++26で`const`版オーバーロードを追加 |
 | `qsort`   | 範囲の並べ替えを行う (function) | |
 
 
diff --git a/reference/cstdlib/bsearch.md b/reference/cstdlib/bsearch.md
new file mode 100644
index 0000000000..4aa62ba65d
--- /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`を保持するオーバーロードが追加された
diff --git a/reference/cstdlib/free_aligned_sized.md b/reference/cstdlib/free_aligned_sized.md
new file mode 100644
index 0000000000..72437a505a
--- /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>`に追加された
diff --git a/reference/cstdlib/free_sized.md b/reference/cstdlib/free_sized.md
new file mode 100644
index 0000000000..3d38f3b0b1
--- /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>`に追加された
diff --git a/reference/cstdlib/memalignment.md b/reference/cstdlib/memalignment.md
new file mode 100644
index 0000000000..41b3ddc2cd
--- /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>`に追加された
diff --git a/reference/cstdlib/realloc.md b/reference/cstdlib/realloc.md
index ac4df8fd20..f5d95687a7 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の場合がエラー性動作となった
diff --git a/reference/cstdlib/strfromd.md b/reference/cstdlib/strfromd.md
new file mode 100644
index 0000000000..2dc68bd436
--- /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>`に追加された
diff --git a/reference/cstdlib/strfromf.md b/reference/cstdlib/strfromf.md
new file mode 100644
index 0000000000..79f37e8fb1
--- /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>`に追加された
diff --git a/reference/cstdlib/strfroml.md b/reference/cstdlib/strfroml.md
new file mode 100644
index 0000000000..767e0b851f
--- /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>`に追加された
diff --git a/reference/cstring.md b/reference/cstring.md
index c7facdb99d..3a01e75f83 100644
--- a/reference/cstring.md
+++ b/reference/cstring.md
@@ -23,9 +23,12 @@
 | 名前 | 説明 | 対応バージョン |
 |------|------|----------------|
 | `memcpy`  | メモリデータをコピーする | |
+| [`memccpy`](cstring/memccpy.md) | メモリデータを指定した文字が現れるまでコピーする | C++26 |
 | `memmove` | メモリデータをコピーする（領域重複可） | |
 | `strcpy`  | 文字列をコピーする | |
 | `strncpy` | 文字列をコピーする（上限サイズ指定） | |
+| [`strdup`](cstring/strdup.md)  | 文字列を複製する | C++26 |
+| [`strndup`](cstring/strndup.md) | 文字列を複製する（上限サイズ指定） | C++26 |
 
 
 ## 結合関数
@@ -65,10 +68,13 @@
 
 | 名前 | 説明 | 対応バージョン |
 |------|------|----------------|
-| `memset`   | メモリデータを指定した値で埋める | |
-| `strerror` | エラーの内容を文字列で取得する | |
-| `strlen`   | 文字列の長さを取得する | |
+| `memset`          | メモリデータを指定した値で埋める | |
+| [`memset_explicit`](cstring/memset_explicit.md) | メモリデータを指定した値で埋める（最適化によって除去されない） | C++26 |
+| `strerror`        | エラーの内容を文字列で取得する | |
+| `strlen`          | 文字列の長さを取得する | |
 
 
 ## 参照
 - [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を参照するようになり、`memccpy`・`strdup`・`strndup`・`memset_explicit`が追加された
diff --git a/reference/cstring/memccpy.md b/reference/cstring/memccpy.md
new file mode 100644
index 0000000000..4c5f324708
--- /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>`に追加された
diff --git a/reference/cstring/memset_explicit.md b/reference/cstring/memset_explicit.md
new file mode 100644
index 0000000000..2782bcf196
--- /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>`に追加された
diff --git a/reference/cstring/strdup.md b/reference/cstring/strdup.md
new file mode 100644
index 0000000000..35d9f5eca6
--- /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>`に追加された
diff --git a/reference/cstring/strndup.md b/reference/cstring/strndup.md
new file mode 100644
index 0000000000..95c0c7f9e5
--- /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>`に追加された
diff --git a/reference/ctime.md b/reference/ctime.md
index 7d19e2ce8a..d00094f597 100644
--- a/reference/ctime.md
+++ b/reference/ctime.md
@@ -10,6 +10,10 @@
 | [`NULL`](/reference/cstddef/null.md) | ヌルポインタ定数 | |
 | `CLOCKS_PER_SEC` | `clock()`関数によって返される1秒あたりの数値 | |
 | [`TIME_UTC`](ctime/time_utc.md) | UTC時間ベースであることを指定するための0より大きい整数定数値 | C++17 |
+| [`TIME_MONOTONIC`](ctime/time_monotonic.md) | 単調増加時間ベースであることを指定するための整数定数値 (処理系定義) | C++26 |
+| [`TIME_ACTIVE`](ctime/time_active.md) | プロセスのCPU時間ベースであることを指定するための整数定数値 (処理系定義) | C++26 |
+| [`TIME_THREAD_ACTIVE`](ctime/time_thread_active.md) | スレッドのCPU時間ベースであることを指定するための整数定数値 (処理系定義) | C++26 |
+| `__STDC_VERSION_TIME_H__` | `<ctime>`が提供するC標準ライブラリ機能のバージョン (`202311L`) | C++26 |
 
 
 ## 型
@@ -36,14 +40,23 @@
 | `clock`        | プログラム実行開始からの経過時間を取得する | |
 | `difftime`     | 2つの時間の差を計算する | |
 | `mktime`       | カレンダー時間から経過秒を生成する | |
+| [`timegm`](ctime/timegm.md)       | UTCのカレンダー時間から経過秒を生成する | C++26 |
 | `gmtime`       | 経過秒からカレンダー時間を生成する | |
+| [`gmtime_r`](ctime/gmtime_r.md)     | 経過秒からカレンダー時間を生成する (利用者が用意したバッファに格納する) | C++26 |
+| `localtime`    | 経過秒からローカル時間のカレンダー時間を生成する | |
+| [`localtime_r`](ctime/localtime_r.md)  | 経過秒からローカル時間のカレンダー時間を生成する (利用者が用意したバッファに格納する) | C++26 |
 | `time`         | 現在時間までの経過秒を取得する | |
 | [`timespec_get`](ctime/timespec_get.md) | 指定したベース時間に基づいた、経過秒と経過ナノ秒を取得する | C++17 |
-| `asctime`      | カレンダー時間を文字列化する | |
-| `ctime`        | 経過秒を日時として文字列化する | |
-| `localtime`    | ローカル時間を取得する | |
+| [`timespec_getres`](ctime/timespec_getres.md) | 指定したベース時間の分解能を取得する | C++26 |
+| [`asctime`](ctime/asctime.md) | カレンダー時間を文字列化する | C++26で非推奨 |
+| [`ctime`](ctime/ctime.md)     | 経過秒を日時として文字列化する | C++26で非推奨 |
 | `strftime`     | 指定したフォーマットでカレンダー時間を文字列化する | |
 
 
 ## 関連項目
 - [`<chrono>`](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を参照するようになり、`timegm`・`gmtime_r`・`localtime_r`・`timespec_getres`と、`TIME_MONOTONIC`・`TIME_ACTIVE`・`TIME_THREAD_ACTIVE`・`__STDC_VERSION_TIME_H__`が追加された。また`asctime`・`ctime`が非推奨となった
diff --git a/reference/ctime/asctime.md b/reference/ctime/asctime.md
new file mode 100644
index 0000000000..63a78f1f58
--- /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を参照するようになり、この関数が非推奨となった
diff --git a/reference/ctime/ctime.md b/reference/ctime/ctime.md
new file mode 100644
index 0000000000..51d7a98c5e
--- /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を参照するようになり、この関数が非推奨となった
diff --git a/reference/ctime/gmtime_r.md b/reference/ctime/gmtime_r.md
new file mode 100644
index 0000000000..3cc8ca39b5
--- /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>`に追加された
diff --git a/reference/ctime/localtime_r.md b/reference/ctime/localtime_r.md
new file mode 100644
index 0000000000..b514ba3bb3
--- /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>`に追加された
diff --git a/reference/ctime/time_active.md b/reference/ctime/time_active.md
new file mode 100644
index 0000000000..65efb1cc6e
--- /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>`に追加された
diff --git a/reference/ctime/time_monotonic.md b/reference/ctime/time_monotonic.md
new file mode 100644
index 0000000000..ce366ec89b
--- /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>`に追加された
diff --git a/reference/ctime/time_t.md b/reference/ctime/time_t.md
index e979350586..5af471d7b9 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]
 
 ### 出力例
 ```
diff --git a/reference/ctime/time_thread_active.md b/reference/ctime/time_thread_active.md
new file mode 100644
index 0000000000..40c0e5dc7c
--- /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>`に追加された
diff --git a/reference/ctime/timegm.md b/reference/ctime/timegm.md
new file mode 100644
index 0000000000..fa552c6524
--- /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>`に追加された
diff --git a/reference/ctime/timespec_getres.md b/reference/ctime/timespec_getres.md
new file mode 100644
index 0000000000..8ea54fc9e0
--- /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>`に追加された
diff --git a/reference/cuchar.md b/reference/cuchar.md
new file mode 100644
index 0000000000..a81a8de4bf
--- /dev/null
+++ b/reference/cuchar.md
@@ -0,0 +1,47 @@
+# cuchar
+* cuchar[meta header]
+* cpp11[meta cpp]
+
+`<cuchar>`ヘッダでは、マルチバイト文字とUnicode文字 (`char8_t`、`char16_t`、`char32_t`) との変換関数を定義する。これらの機能は、`std`名前空間に属することを除いてC言語の標準ライブラリ`<uchar.h>`ヘッダと同じである (ただし`char8_t`、`char16_t`、`char32_t`型は宣言しない)。
+
+
+## 型
+
+| 名前 | 説明 | 対応バージョン |
+|------|------|----------------|
+| [`size_t`](/reference/cstddef/size_t.md) | 符号なし整数型 | C++11 |
+| `mbstate_t` | マルチバイト文字とワイド文字の変換状態を保持する型 | C++11 |
+
+
+## 変換関数
+
+| 名前 | 説明 | 対応バージョン |
+|------|------|----------------|
+| [`mbrtoc8`](cuchar/mbrtoc8.md)  | マルチバイト文字を、UTF-8文字 (`char8_t`) に変換する | C++26 |
+| [`c8rtomb`](cuchar/c8rtomb.md)  | 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++17
+
+
+## 関連項目
+- [`<cstdlib>`](cstdlib.md)
+
+
+## 参照
+- [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を参照するようになり、`mbrtoc8`・`c8rtomb`・`__STDC_VERSION_UCHAR_H__`が追加された
diff --git a/reference/cuchar/c8rtomb.md b/reference/cuchar/c8rtomb.md
new file mode 100644
index 0000000000..4080e137c0
--- /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>`に追加された
diff --git a/reference/cuchar/mbrtoc8.md b/reference/cuchar/mbrtoc8.md
new file mode 100644
index 0000000000..558f85a943
--- /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>`に追加された