Wikibooks

C言語/標準ライブラリ

< C言語
typeof演算子とtypeof unqual演算子 C言語
標準ライブラリ 		概念モデル

C言語では、他の言語とでは「命令」として持つような入出力や文字列操作などの機能を標準ライブラリとして提供しています[1]。そのため、C言語を学ぶことは、どの様なライブラリ関数があるのか？、ライブラリ関数がどのヘッダーで宣言されているのか？、を覚えることが多くなります。 また、標準ライブラリで定義されている、型やマクロも同様に重要です。

7. Library

編集

C言語の国際規格の「ライブラリ」の章の節ごとにコメンタリーを加えました。

7.1 Introduction

編集

C言語の標準ライブラリについて、ここでは基本的な概念と用語の定義、標準ヘッダーの内容、ライブラリ関数の使用法、そして予約された識別子に関する説明が行われます。

7.1.1 Definitions of terms

編集
  1. String（文字列）
    文字列は、連続した文字の並びであり、最初のヌル文字（終端文字）で終了します。
    マルチバイト文字列という用語は、マルチバイト文字を含む文字列に特別な処理が必要な場合や、ワイド文字列との混乱を避けるために使われることがあります。
    文字列へのポインターは、その最初の文字（最もアドレスが低い文字）を指します。
    文字列の長さはヌル文字の前のバイト数であり、文字列の値は含まれる文字の順序通りの値です。
  2. Decimal-point character（小数点文字）
    小数点文字は、浮動小数点数を文字列に変換する際、またはその逆の場合に使用され、小数部の開始を示します。
    通常はピリオド（.）で表されますが、setlocale関数により変更可能です。
  3. Null wide character（ヌルワイド文字）
    コード値がゼロのワイド文字です。
  4. Wide string（ワイド文字列）
    ワイド文字の連続した並びであり、最初のヌルワイド文字で終了します。
    ワイド文字列へのポインターは、その最初のワイド文字（最もアドレスが低いワイド文字）を指します。
    ワイド文字列の長さはヌルワイド文字の前のワイド文字数であり、ワイド文字列の値は含まれるワイド文字のコード値の順序通りです。
  5. Shift sequence（シフトシーケンス）
    マルチバイト文字列内の連続したバイトの並びであり、シフト状態の変更を引き起こす可能性があります。
    シフトシーケンスは対応するワイド文字を持たず、代わりに隣接するマルチバイト文字の補助として扱われます。
    「空白文字」とは、isspace関数で定義された（実行時の）空白文字を指し、「空白ワイド文字」とは、iswspace関数で定義された（実行時の）空白ワイド文字を指します。

7.1.2 Standard headers

編集
  1. 標準ヘッダー
    各ライブラリ関数はヘッダーで宣言され、その内容は#includeプリプロセッサディレクティブにより利用可能になります。
    ヘッダーは、関連する関数群や、それらの関数の使用を促進するために必要な型やマクロを宣言します。
    特定のマクロ（例：__STDC_IEC_60559_BFP__など）を定義する実装は、対応する付録（F、G、H、K）の仕様に従わなければなりません。
  2. Decimal floating types（小数浮動小数点型）をサポートしない実装
    小数浮動小数点型をサポートしない実装は、これらの型に特有のインターフェースやその側面をサポートする必要はありません。
  3. 標準ヘッダーの一覧
    標準ヘッダーには以下が含まれます：
  4. 同名のファイル
    上記の<と>で区切られたシーケンスと同名のファイルが、実装の一部として提供されない場合、それを含む動作は未定義です。
  5. 標準ヘッダーのインクルード順
    標準ヘッダーは任意の順序でインクルード可能で、同じスコープで複数回インクルードしても、1回のみインクルードした場合と異なる影響はありません。
    ただし、assert.hのインクルード効果はNDEBUGの定義に依存します。
  6. 新しい識別子
    一部の標準ヘッダーは以前のバージョンには存在しなかった識別子を定義または宣言し、適応のためのバージョンマクロも定義されます。
  7. オブジェクト型マクロ
    オブジェクト型マクロの定義は必要に応じて括弧で保護され、単一の識別子のようにグループ化される必要があります。
  8. 外部リンケージ
    ライブラリ関数の宣言は外部リンケージを持たなければなりません。
  9. 標準ヘッダーの内容の概要
    標準ヘッダーの内容の概要は付録Bに示されています。

7.1.3 Reserved identifiers

編集
  1. 予約された識別子
    各ヘッダーは、関連するサブクローズでリストされたすべての識別子を宣言または定義し、オプションで将来のライブラリ指示サブクローズにリストされた識別子や、任意の使用またはファイルスコープ識別子として使用するために常に予約されている識別子を宣言または定義します。
    実装が外部定義で提供するすべての潜在的に予約された識別子は、任意の使用のために予約されます。
    外部リンケージを持たない限り、潜在的に予約された識別子の外部定義を提供してはなりません。
    実装が提供する他のすべての潜在的に予約された識別子（マクロとして含む）は、関連するヘッダーがインクルードされるときに任意の使用のために予約されます。

7.1.4 Use of library functions

編集
  1. ライブラリ関数の使用法
    関数の引数が無効な値を持つ場合や、変数引数の型が期待されるものと異なる場合、その動作は未定義です。
    関数に渡されるポインターが配列として記述されている場合、すべてのアドレス計算とオブジェクトへのアクセスが有効でなければなりません。
    各ライブラリ関数は、関数のようなマクロとして追加で実装されることがあります。この場合、マクロ定義はローカルで#undefを使用して解除できます。
    マクロとして実装されたライブラリ関数の呼び出しは、各引数を一度だけ評価するコードに展開されます。
    関数のアドレスを取得することは、マクロとして定義されていても可能です。
  2. ヘッダーなしの関数宣言
    ヘッダー内の型に言及せずに関数を宣言できる場合、その関数を宣言してヘッダーを含まずに使用することが許可されます。
  3. シーケンスポイント
    ライブラリ関数が戻る直前にシーケンスポイントがあります。
  4. 再入不可
    標準ライブラリの関数は再入可能ではなく、静的またはスレッドストレージ期間のオブジェクトを変更する可能性があります。
  5. データ競合の防止
    ライブラリ関数は、直接または間接的に、現在のスレッド以外のスレッドによってアクセス可能なオブジェクトにアクセスしてはなりません。
    ライブラリ関数は、直接または間接的に、現在のスレッド以外のスレッドによってアクセス可能なオブジェクトを変更してはなりません。
  6. スレッド内操作
    ライブラリ関数は、ユーザーに見える副作用がある操作を行う場合には、すべての操作を現在のスレッド内で実行しなければなりません。

例

編集

atoi関数の使用例: 

// 関連するヘッダーを使用して（おそらくマクロ展開を生成）
#include <stdlib.h>
const char *str;
/* ... */
i = atoi(str);

// 関連するヘッダーを使用して（真の関数参照が生成されることを確実に）
#include <stdlib.h>
#undef atoi
const char *str;
/* ... */
i = atoi(str);
// または
#include <stdlib.h>
const char *str;
/* ... */
i = (atoi)(str);

// 明示的な宣言で使用
extern int atoi(const char *);
const char *str;
/* ... */
i = atoi(str);

atoi関数はこれらの方法で使用できます。ただし、シグナルハンドラなど、標準ライブラリ関数を呼び出すことができない状況もあります。

まとめ

このセクションでは、C標準ライブラリについていくつかの重要な概念が説明されています。

まず、「用語の定義」セクションでは、文字列、マルチバイト文字列、ワイド文字列、およびシフトシーケンスなどの用語が定義されています。これらの定義は、Cプログラムの文字列や文字処理に関する理解を深めるのに役立ちます。

次に、「標準ヘッダー」セクションでは、C標準ライブラリで提供される関数や型が宣言されたヘッダーファイルについて説明されています。これらのヘッダーファイルは、プリプロセスディレクティブ#includeを使用してインクルードされ、関数や型の宣言を提供します。また、特定の機能をサポートするために、特定のマクロが定義される場合、該当の仕様に準拠する必要があることも述べられています。

次に、「予約された識別子」セクションでは、各ヘッダーが定義するまたは宣言する識別子に関する規則について説明されています。これには、ポテンシャルに予約された識別子や外部リンケージを持つ識別子などが含まれます。

最後に、「ライブラリ関数の使用」セクションでは、ライブラリ関数の使用に関する一般的な規則が説明されています。これには、無効な値の引数を渡すことの影響や、マクロとして実装されたライブラリ関数の扱い方などが含まれます。また、ライブラリ関数の呼び出しに関する注意事項や、データ競合の防止についても説明されています。

これらのセクションを理解することで、Cプログラムで標準ライブラリを効果的に活用し、安全かつ効率的なコードを書くことができます。

条件付き機能マクロ

編集

C11以降では標準ライブラリの機能の一部の実装が任意になりました[2]。 例えば、処理系が complex.h で宣言される複素数機能をサポートしない場合、マクロ __STDC_NO_COMPLEX__ が 1 に定義されます。 また特定のヘッダーファイルとは結びつきませんが、可変長配列機能をサポートしない場合は、マクロ __STDC_NO_VLA__ が 1 に定義されます。

「C言語/前処理指令#事前定義済みマクロ定数一覧」も参照

数学ライブラリー libm

編集

Unix系のOSでは、complex.h, math.h, ieeefp.h, tgmath.h で定義された関数の定義は、暗黙でリンクされる libc ではなく追加で libm に実装されているので、 libm を -lm で追加リンクする必要があります。 

% cat test-libm.c
#include <stdio.h>
#include <math.h>

int main(void){
    printf("sin(PI/2) = %f\n", sin(3.1415926536/2));
}
% cc test-libm.c -o test-libm
ld: error: undefined symbol: sin
>>> referenced by test-libm.c
>>>               /var/tmp/test-libm-d56553.o:(main)
cc: error: linker command failed with exit code 1 (use -v to see invocation)
% cc test-libm.c -o test-libm -lm
% ./test-libm
sin(PI/2) = 1.000000

境界検査インターフェース

編集

C11以降では新しく境界検査インターフェース（ Bounds-checking interfaces ）が提供され、マクロ __STDC_WANT_LIB_EXT1__ によって制御するようになりました[3]。 __STDC_WANT_LIB_EXT1__は利用者が定義するもので、境界検査インターフェースを宣言している標準ヘッダーファイルをインクルードする前に定義を行います。 __STDC_WANT_LIB_EXT1__を 1 に定義すると境界検査インターフェースの使用を求め、0 に定義すると境界検査インターフェースの使用を求めない意味になります。 ANSI C 以降では未定義のマクロの値は 0 とみなされる[4][5]ので、__STDC_WANT_LIB_EXT1__を定義していない従来のソースコードは「境界検査インターフェースの使用を求めない」と解されます。

__STDC_WANT_LIB_EXT1__の使用例
#define __STDC_WANT_LIB_EXT1__ 1
#include <stdio.h>

int main(void) {
  char buf[16];

  puts("Please enter some string.");
  gets_s(buf, sizeof(buf));
  puts(buf);
}
上の例では、gets_s() が境界検査インターフェースを提供する関数です。
__STDC_WANT_IEC_60559_EXT__

C23では、ユーザー定義マクロ __STDC_WANT_IEC_60559_EXT__ と処理系定義マクロ __STDC_IEC_60559_DFP__ などによってISO/IEC 60559:2020(IEEE 754として知られる浮動小数点算術に関する標準)の機能の要求を制御する予定です[6]。

標準ライブラリのヘッダー一覧

編集

トーク:C言語#C言語/標準ライブラリ以下のページに書く、関数などのテンプレートに関数のテンプレート案があります。

標準ライブラリ関数サマリー

編集

C17 の Annex B (informative) Library summary から、関数定義部分を抜き出しました。各関数は解説ページへのリンクになっています。

assert.h

編集
Diagnostics <assert.h>
void assert(scalar expression);

complex.h

編集
Complex <complex.h>
double complex cacos(double complex z);
float complex cacosf(float complex z);
long double complex cacosl(long double complex z);
double complex casin(double complex z);
float complex casinf(float complex z);
long double complex casinl(long double complex z);
double complex catan(double complex z);
float complex catanf(float complex z);
long double complex catanl(long double complex z);
double complex ccos(double complex z);
float complex ccosf(float complex z);
long double complex ccosl(long double complex z);
double complex csin(double complex z);
float complex csinf(float complex z);
long double complex csinl(long double complex z);
double complex ctan(double complex z);
float complex ctanf(float complex z);
long double complex ctanl(long double complex z);
double complex cacosh(double complex z);
float complex cacoshf(float complex z);
long double complex cacoshl(long double complex z);
double complex casinh(double complex z);
float complex casinhf(float complex z);
long double complex casinhl(long double complex z);
double complex catanh(double complex z);
float complex catanhf(float complex z);
long double complex catanhl(long double complex z);
double complex ccosh(double complex z);
float complex ccoshf(float complex z);
long double complex ccoshl(long double complex z);
double complex csinh(double complex z);
float complex csinhf(float complex z);
long double complex csinhl(long double complex z);
double complex ctanh(double complex z);
float complex ctanhf(float complex z);
long double complex ctanhl(long double complex z);
double complex cexp(double complex z);
float complex cexpf(float complex z);
long double complex cexpl(long double complex z);
double complex clog(double complex z);
float complex clogf(float complex z);
long double complex clogl(long double complex z);
double cabs(double complex z);
float cabsf(float complex z);
long double cabsl(long double complex z);
double complex cpow(double complex x, double complex y);
float complex cpowf(float complex x, float complex y);
long double complex cpowl(long double complex x,long double complex y);
double complex csqrt(double complex z);
float complex csqrtf(float complex z);
long double complex csqrtl(long double complex z);
double carg(double complex z);
float cargf(float complex z);
long double cargl(long double complex z);
double cimag(double complex z);
float cimagf(float complex z);
long double cimagl(long double complex z);
double complex CMPLX(double x, double y);
float complex CMPLXF(float x, float y);
long double complex CMPLXL(long double x, long double y);
double complex conj(double complex z);
float complex conjf(float complex z);
long double complex conjl(long double complex z);
double complex cproj(double complex z);
float complex cprojf(float complex z);
long double complex cprojl(long double complex z);
double creal(double complex z);
float crealf(float complex z);
long double creall(long double complex z);

ctype.h

編集
Character handling <ctype.h>
int isalnum(int c);
int isalpha(int c);
int isblank(int c);
int iscntrl(int c);
int isdigit(int c);
int isgraph(int c);
int islower(int c);
int isprint(int c);
int ispunct(int c);
int isspace(int c);
int isupper(int c);
int isxdigit(int c);
int tolower(int c);
int toupper(int c);

errno.h

編集
Errors <errno.h>

fenv.h

編集
Floating-point environment <fenv.h>
int feclearexcept(int excepts);
int fegetexceptflag(fexcept_t *flagp, int excepts);
int feraiseexcept(int excepts);
int fesetexceptflag(const fexcept_t *flagp,int excepts);
int fetestexcept(int excepts);
int fegetround(void);
int fesetround(int round);
int fegetenv(fenv_t *envp);
int feholdexcept(fenv_t *envp);
int fesetenv(const fenv_t *envp);
int feupdateenv(const fenv_t *envp);

float.h

編集
Characteristics of floating types <float.h>

inttypes.h

編集
Format conversion of integer types <inttypes.h>
intmax_t imaxabs(intmax_t j);
imaxdiv_t imaxdiv(intmax_t numer, intmax_t denom);
intmax_t strtoimax(const char * restrict nptr,char ** restrict endptr, int base);
uintmax_t strtoumax(const char * restrict nptr,char ** restrict endptr, int base);
intmax_t wcstoimax(const wchar_t * restrict nptr,wchar_t ** restrict endptr, int base);
uintmax_t wcstoumax(const wchar_t * restrict nptr,wchar_t ** restrict endptr, int base);

iso646.h

編集
Alternative spellings <iso646.h>

limits.h

編集
Sizes of integer types <limits.h>

locale.h

編集
Localization <locale.h>

math.h

編集
Mathematics <math.h>
int fpclassify(real-floating x);
int isfinite(real-floating x);
int isinf(real-floating x);
int isnan(real-floating x);
int isnormal(real-floating x);
int signbit(real-floating x);
double acos(double x);
float acosf(float x);
long double acosl(long double x);
double asin(double x);
float asinf(float x);
long double asinl(long double x);
double atan(double x);
float atanf(float x);
long double atanl(long double x);
double atan2(double y, double x);
float atan2f(float y, float x);
long double atan2l(long double y, long double x);
double cos(double x);
float cosf(float x);
long double cosl(long double x);
double sin(double x);
float sinf(float x);
long double sinl(long double x);
double tan(double x);
float tanf(float x);
long double tanl(long double x);
double acosh(double x);
float acoshf(float x);
long double acoshl(long double x);
double asinh(double x);
float asinhf(float x);
long double asinhl(long double x);
double atanh(double x);
float atanhf(float x);
long double atanhl(long double x);
double cosh(double x);
float coshf(float x);
long double coshl(long double x);
double sinh(double x);
float sinhf(float x);
long double sinhl(long double x);
double tanh(double x);
float tanhf(float x);
long double tanhl(long double x);
double exp(double x);
float expf(float x);
long double expl(long double x);
double exp2(double x);
float exp2f(float x);
long double exp2l(long double x);
double expm1(double x);
float expm1f(float x);
long double expm1l(long double x);
double frexp(double value, int *exp);
float frexpf(float value, int *exp);
long double frexpl(long double value, int *exp);
int ilogb(double x);
int ilogbf(float x);
int ilogbl(long double x);
double ldexp(double x, int exp);
float ldexpf(float x, int exp);
long double ldexpl(long double x, int exp);
double log(double x);
float logf(float x);
long double logl(long double x);
double log10(double x);
float log10f(float x);
long double log10l(long double x);
double log1p(double x);
float log1pf(float x);
long double log1pl(long double x);
double log2(double x);
float log2f(float x);
long double log2l(long double x);
double logb(double x);
float logbf(float x);
long double logbl(long double x);
double modf(double value, double *iptr);
float modff(float value, float *iptr);
long double modfl(long double value, long double *iptr);
double scalbn(double x, int n);
float scalbnf(float x, int n);
long double scalbnl(long double x, int n);
double scalbln(double x, long int n);
float scalblnf(float x, long int n);
long double scalblnl(long double x, long int n);
double cbrt(double x);
float cbrtf(float x);
long double cbrtl(long double x);
double fabs(double x);
float fabsf(float x);
long double fabsl(long double x);
double hypot(double x, double y);
float hypotf(float x, float y);
long double hypotl(long double x, long double y);
double pow(double x, double y);
float powf(float x, float y);
long double powl(long double x, long double y);
double sqrt(double x);
float sqrtf(float x);
long double sqrtl(long double x);
double erf(double x);
float erff(float x);
long double erfl(long double x);
double erfc(double x);
float erfcf(float x);
long double erfcl(long double x);
double lgamma(double x);
float lgammaf(float x);
long double lgammal(long double x);
double tgamma(double x);
float tgammaf(float x);
long double tgammal(long double x);
double ceil(double x);
float ceilf(float x);
long double ceill(long double x);
double floor(double x);
float floorf(float x);
long double floorl(long double x);
double nearbyint(double x);
float nearbyintf(float x);
long double nearbyintl(long double x);
double rint(double x);
float rintf(float x);
long double rintl(long double x);
long int lrint(double x);
long int lrintf(float x);
long int lrintl(long double x);
long long int llrint(double x);
long long int llrintf(float x);
long long int llrintl(long double x);
double round(double x);
float roundf(float x);
long double roundl(long double x);
long int lround(double x);
long int lroundf(float x);
long int lroundl(long double x);
long long int llround(double x);
long long int llroundf(float x);
long long int llroundl(long double x);
double trunc(double x);
float truncf(float x);
long double truncl(long double x);
double fmod(double x, double y);
float fmodf(float x, float y);
long double fmodl(long double x, long double y);
double remainder(double x, double y);
float remainderf(float x, float y);
long double remainderl(long double x, long double y);
double remquo(double x, double y, int *quo);
float remquof(float x, float y, int *quo);
long double remquol(long double x, long double y,int *quo);
double copysign(double x, double y);
float copysignf(float x, float y);
long double copysignl(long double x, long double y);
double nan(const char *tagp);
float nanf(const char *tagp);
long double nanl(const char *tagp);
double nextafter(double x, double y);
float nextafterf(float x, float y);
long double nextafterl(long double x, long double y);
double nexttoward(double x, long double y);
float nexttowardf(float x, long double y);
long double nexttowardl(long double x, long double y);
double fdim(double x, double y);
float fdimf(float x, float y);
long double fdiml(long double x, long double y);
double fmax(double x, double y);
float fmaxf(float x, float y);
long double fmaxl(long double x, long double y);
double fmin(double x, double y);
float fminf(float x, float y);
long double fminl(long double x, long double y);
double fma(double x, double y, double z);
float fmaf(float x, float y, float z);
long double fmal(long double x, long double y,long double z);
int isgreater(real-floating x, real-floating y);
int isgreaterequal(real-floating x, real-floating y);
int isless(real-floating x, real-floating y);
int islessequal(real-floating x, real-floating y);
int islessgreater(real-floating x, real-floating y);
int isunordered(real-floating x, real-floating y);

setjmp.h

編集
Nonlocal jumps <setjmp.h>
int setjmp(jmp_buf env);
_Noreturn void longjmp(jmp_buf env, int val);

signal.h

編集
Signal handling <signal.h>
int raise(int sig);

stdalign.h

編集
Alignment <stdalign.h>

stdarg.h

編集
Variable arguments <stdarg.h>
type va_arg(va_list ap, type);
void va_copy(va_list dest, va_list src);
void va_end(va_list ap);
void va_start(va_list ap, parmN);

stdatomic.h

編集
Atomics <stdatomic.h>
void atomic_init(volatile A *obj, C value);
type kill_dependency(type y);
void atomic_thread_fence(memory_order order);
void atomic_signal_fence(memory_order order);
_Bool atomic_is_lock_free(const volatile A *obj);
void atomic_store(volatile A *object, C desired);
void atomic_store_explicit(volatile A *object,C desired, memory_order order);
C atomic_load(volatile A *object);
C atomic_load_explicit(volatile A *object,memory_order order);
C atomic_exchange(volatile A *object, C desired);
C atomic_exchange_explicit(volatile A *object,C desired, memory_order order);
_Bool atomic_compare_exchange_strong(volatile A *object,C *expected, C desired);
_Bool atomic_compare_exchange_strong_explicit( volatile A *object, C *expected, C desired,memory_order success, memory_order failure);
_Bool atomic_compare_exchange_weak(volatile A *object,C *expected, C desired);
_Bool atomic_compare_exchange_weak_explicit( volatile A *object, C *expected, C desired,memory_order success, memory_order failure);
C atomic_fetch_key(volatile A *object, M operand);
C atomic_fetch_key_explicit(volatile A *object,M operand, memory_order order);
_Bool atomic_flag_test_and_set(volatile atomic_flag *object);
_Bool atomic_flag_test_and_set_explicit(volatile atomic_flag *object, memory_order order);
void atomic_flag_clear(volatile atomic_flag *object);
void atomic_flag_clear_explicit(volatile atomic_flag *object, memory_order order);

stdbool.h

編集
Boolean type and values <stdbool.h>

stddef.h

編集
Common definitions <stddef.h>

stdint.h

編集
Integer types <stdint.h>

stdio.h

編集
Input/output <stdio.h>
int remove(const char *filename);
int rename(const char *old, const char *new);
int fclose(FILE *stream);
int fflush(FILE *stream);
void setbuf(FILE * restrict stream,char * restrict buf);
int setvbuf(FILE * restrict stream, char * restrict buf,int mode, size_t size);
int fprintf(FILE * restrict stream,const char * restrict format, ...);
int fscanf(FILE * restrict stream,const char * restrict format, ...);
int printf(const char * restrict format, ...);
int scanf(const char * restrict format, ...);
int snprintf(char * restrict s, size_t n,const char * restrict format, ...);
int sprintf(char * restrict s,const char * restrict format, ...);
int sscanf(const char * restrict s,const char * restrict format, ...);
int vfprintf(FILE * restrict stream,const char * restrict format, va_list arg);
int vfscanf(FILE * restrict stream,const char * restrict format, va_list arg);
int vprintf(const char * restrict format, va_list arg);
int vscanf(const char * restrict format, va_list arg);
int vsnprintf(char * restrict s, size_t n,const char * restrict format, va_list arg);
int vsprintf(char * restrict s,const char * restrict format, va_list arg);
int vsscanf(const char * restrict s,const char * restrict format, va_list arg);
int fgetc(FILE *stream);
int fputc(int c, FILE *stream);
int fputs(const char * restrict s,FILE * restrict stream);
int getc(FILE *stream);
int getchar(void);
int putc(int c, FILE *stream);
int putchar(int c);
int puts(const char *s);
int ungetc(int c, FILE *stream);
size_t fread(void * restrict ptr, size_t size, size_t nmemb,FILE * restrict stream);
size_t fwrite(const void * restrict ptr, size_t size, size_t nmemb,FILE * restrict stream);
int fgetpos(FILE * restrict stream,fpos_t * restrict pos);
int fseek(FILE *stream, long int offset, int whence);
int fsetpos(FILE *stream, const fpos_t *pos);
long int ftell(FILE *stream);
void rewind(FILE *stream);
void clearerr(FILE *stream);
int feof(FILE *stream);
int ferror(FILE *stream);
void perror(const char *s);
errno_t tmpfile_s(FILE * restrict * restrict streamptr);
errno_t tmpnam_s(char *s, rsize_t maxsize);
errno_t fopen_s(FILE * restrict * restrict streamptr, const char * restrict filename,const char * restrict mode);
errno_t freopen_s(FILE * restrict * restrict newstreamptr, const char * restrict filename, const char * restrict mode,FILE * restrict stream);
int fprintf_s(FILE * restrict stream,const char * restrict format, ...);
int fscanf_s(FILE * restrict stream,const char * restrict format, ...);
int printf_s(const char * restrict format, ...);
int scanf_s(const char * restrict format, ...);
int snprintf_s(char * restrict s, rsize_t n,const char * restrict format, ...);
int sprintf_s(char * restrict s, rsize_t n,const char * restrict format, ...);
int sscanf_s(const char * restrict s,const char * restrict format, ...);
int vfprintf_s(FILE * restrict stream, const char * restrict format,va_list arg);
int vfscanf_s(FILE * restrict stream, const char * restrict format,va_list arg);
int vprintf_s(const char * restrict format,va_list arg);
int vscanf_s(const char * restrict format,va_list arg);
int vsnprintf_s(char * restrict s, rsize_t n, const char * restrict format,va_list arg);
int vsprintf_s(char * restrict s, rsize_t n, const char * restrict format,va_list arg);
int vsscanf_s(const char * restrict s, const char * restrict format,va_list arg);

stdlib.h

編集
General utilities <stdlib.h>
double atof(const char *nptr);
int atoi(const char *nptr);
long int atol(const char *nptr);
long long int atoll(const char *nptr);
double strtod(const char * restrict nptr,char ** restrict endptr);
float strtof(const char * restrict nptr,char ** restrict endptr);
long double strtold(const char * restrict nptr,char ** restrict endptr);
long int strtol(const char * restrict nptr,char ** restrict endptr, int base);
long long int strtoll(const char * restrict nptr,char ** restrict endptr, int base);
unsigned long int strtoul( const char * restrict nptr,char ** restrict endptr, int base);
unsigned long long int strtoull( const char * restrict nptr,char ** restrict endptr, int base);
int rand(void);
void srand(unsigned int seed);
void free(void *ptr);
_Noreturn void abort(void);
_Noreturn void exit(int status);
_Noreturn void _Exit(int status);
_Noreturn void quick_exit(int status);
int system(const char *string);
int abs(int j);
long int labs(long int j);
long long int llabs(long long int j);
div_t div(int numer, int denom);
ldiv_t ldiv(long int numer, long int denom);
lldiv_t lldiv(long long int numer,long long int denom);
int mblen(const char *s, size_t n);
int mbtowc(wchar_t * restrict pwc,const char * restrict s, size_t n);
int wctomb(char *s, wchar_t wchar);
size_t mbstowcs(wchar_t * restrict pwcs,const char * restrict s, size_t n);
size_t wcstombs(char * restrict s,const wchar_t * restrict pwcs, size_t n);
constraint_handler_t set_constraint_handler_s(constraint_handler_t handler);
void abort_handler_s( const char * restrict msg, void * restrict ptr,errno_t error);
void ignore_handler_s( const char * restrict msg, void * restrict ptr,errno_t error);
errno_t getenv_s(size_t * restrict len, char * restrict value, rsize_t maxsize,const char * restrict name);
errno_t wctomb_s(int * restrict status, char * restrict s, rsize_t smax,wchar_t wc);
errno_t mbstowcs_s(size_t * restrict retval, wchar_t * restrict dst, rsize_t dstmax,const char * restrict src, rsize_t len);
errno_t wcstombs_s(size_t * restrict retval, char * restrict dst, rsize_t dstmax,const wchar_t * restrict src, rsize_t len);

stdnoreturn.h

編集
_Noreturn <stdnoreturn.h>

string.h

編集
String handling <string.h>
int memcmp(const void *s1, const void *s2, size_t n);
int strcmp(const char *s1, const char *s2);
int strcoll(const char *s1, const char *s2);
int strncmp(const char *s1, const char *s2, size_t n);
size_t strxfrm(char * restrict s1,const char * restrict s2, size_t n);
size_t strcspn(const char *s1, const char *s2);
size_t strspn(const char *s1, const char *s2);
size_t strlen(const char *s);
errno_t memcpy_s(void * restrict s1, rsize_t s1max,const void * restrict s2, rsize_t n);
errno_t memmove_s(void *s1, rsize_t s1max,const void *s2, rsize_t n);
errno_t strcpy_s(char * restrict s1, rsize_t s1max,const char * restrict s2);
errno_t strncpy_s(char * restrict s1, rsize_t s1max, const char * restrict s2,rsize_t n);
errno_t strcat_s(char * restrict s1, rsize_t s1max,const char * restrict s2);
errno_t strncat_s(char * restrict s1, rsize_t s1max, const char * restrict s2,rsize_t n);
errno_t strerror_s(char *s, rsize_t maxsize,errno_t errnum);
size_t strerrorlen_s(errno_t errnum);
size_t strnlen_s(const char *s, size_t maxsize);

tgmath.h

編集
Type-generic math <tgmath.h>

threads.h

編集
Threads <threads.h>
int cnd_broadcast(cnd_t *cond);
void cnd_destroy(cnd_t *cond);
int cnd_init(cnd_t *cond);
int cnd_signal(cnd_t *cond);
int cnd_timedwait(cnd_t *restrict cond, mtx_t *restrict mtx,const struct timespec *restrict ts);
int cnd_wait(cnd_t *cond, mtx_t *mtx);
void mtx_destroy(mtx_t *mtx);
int mtx_init(mtx_t *mtx, int type);
int mtx_lock(mtx_t *mtx);
int mtx_timedlock(mtx_t *restrict mtx,const struct timespec *restrict ts);
int mtx_trylock(mtx_t *mtx);
int mtx_unlock(mtx_t *mtx);
int thrd_create(thrd_t *thr, thrd_start_t func,void *arg);
thrd_t thrd_current(void);
int thrd_detach(thrd_t thr);
int thrd_equal(thrd_t thr0, thrd_t thr1);
_Noreturn void thrd_exit(int res);
int thrd_join(thrd_t thr, int *res);
int thrd_sleep(const struct timespec *duration,struct timespec *remaining);
void thrd_yield(void);
int tss_create(tss_t *key, tss_dtor_t dtor);
void tss_delete(tss_t key);
int tss_set(tss_t key, void *val);

time.h

編集
Date and time <time.h>
clock_t clock(void);
double difftime(time_t time1, time_t time0);
time_t mktime(struct tm *timeptr);
time_t time(time_t *timer);
int timespec_get(timespec *ts, int base);
size_t strftime(char * restrict s, size_t maxsize, const char * restrict format,const struct tm * restrict timeptr);
errno_t asctime_s(char *s, rsize_t maxsize,const struct tm *timeptr);
errno_t ctime_s(char *s, rsize_t maxsize,const time_t *timer);

uchar.h

編集
Unicode utilities <uchar.h>
size_t mbrtoc16(char16_t * restrict pc16, const char * restrict s, size_t n,mbstate_t * restrict ps);
size_t c16rtomb(char * restrict s, char16_t c16,mbstate_t * restrict ps);
size_t mbrtoc32(char32_t * restrict pc32, const char * restrict s, size_t n,mbstate_t * restrict ps);
size_t c32rtomb(char * restrict s, char32_t c32,mbstate_t * restrict ps);

wchar.h

編集
Extended multibyte/wide character utilities <wchar.h>
int fwprintf(FILE * restrict stream,const wchar_t * restrict format, ...);
int fwscanf(FILE * restrict stream,const wchar_t * restrict format, ...);
int swprintf(wchar_t * restrict s, size_t n,const wchar_t * restrict format, ...);
int swscanf(const wchar_t * restrict s,const wchar_t * restrict format, ...);
int vfwprintf(FILE * restrict stream,const wchar_t * restrict format, va_list arg);
int vfwscanf(FILE * restrict stream,const wchar_t * restrict format, va_list arg);
int vswprintf(wchar_t * restrict s, size_t n,const wchar_t * restrict format, va_list arg);
int vswscanf(const wchar_t * restrict s,const wchar_t * restrict format, va_list arg);
int vwprintf(const wchar_t * restrict format,va_list arg);
int vwscanf(const wchar_t * restrict format,va_list arg);
int wprintf(const wchar_t * restrict format, ...);
int wscanf(const wchar_t * restrict format, ...);
wint_t fgetwc(FILE *stream);
wint_t fputwc(wchar_t c, FILE *stream);
int fputws(const wchar_t * restrict s,FILE * restrict stream);
int fwide(FILE *stream, int mode);
wint_t getwc(FILE *stream);
wint_t getwchar(void);
wint_t putwc(wchar_t c, FILE *stream);
wint_t putwchar(wchar_t c);
wint_t ungetwc(wint_t c, FILE *stream);
double wcstod(const wchar_t * restrict nptr,wchar_t ** restrict endptr);
float wcstof(const wchar_t * restrict nptr,wchar_t ** restrict endptr);
long double wcstold(const wchar_t * restrict nptr,wchar_t ** restrict endptr);
long int wcstol(const wchar_t * restrict nptr,wchar_t ** restrict endptr, int base);
long long int wcstoll(const wchar_t * restrict nptr,wchar_t ** restrict endptr, int base);
unsigned long int wcstoul(const wchar_t * restrict nptr,wchar_t ** restrict endptr, int base);
unsigned long long int wcstoull( const wchar_t * restrict nptr,wchar_t ** restrict endptr, int base);
int wcscmp(const wchar_t *s1, const wchar_t *s2);
int wcscoll(const wchar_t *s1, const wchar_t *s2);
int wcsncmp(const wchar_t *s1, const wchar_t *s2,size_t n);
size_t wcsxfrm(wchar_t * restrict s1,const wchar_t * restrict s2, size_t n);
int wmemcmp(const wchar_t *s1, const wchar_t *s2,size_t n);
size_t wcscspn(const wchar_t *s1, const wchar_t *s2);
size_t wcsspn(const wchar_t *s1, const wchar_t *s2);
size_t wcslen(const wchar_t *s);
size_t wcsftime(wchar_t * restrict s, size_t maxsize, const wchar_t * restrict format,const struct tm * restrict timeptr);
wint_t btowc(int c);
int wctob(wint_t c);
int mbsinit(const mbstate_t *ps);
size_t mbrlen(const char * restrict s, size_t n,mbstate_t * restrict ps);
size_t mbrtowc(wchar_t * restrict pwc, const char * restrict s, size_t n,mbstate_t * restrict ps);
size_t wcrtomb(char * restrict s, wchar_t wc,mbstate_t * restrict ps);
size_t mbsrtowcs(wchar_t * restrict dst, const char ** restrict src, size_t len,mbstate_t * restrict ps);
size_t wcsrtombs(char * restrict dst, const wchar_t ** restrict src, size_t len,mbstate_t * restrict ps);
int fwprintf_s(FILE * restrict stream,const wchar_t * restrict format, ...);
int fwscanf_s(FILE * restrict stream,const wchar_t * restrict format, ...);
int snwprintf_s(wchar_t * restrict s, rsize_t n,const wchar_t * restrict format, ...);
int swprintf_s(wchar_t * restrict s, rsize_t n,const wchar_t * restrict format, ...);
int swscanf_s(const wchar_t * restrict s,const wchar_t * restrict format, ...);
int vfwprintf_s(FILE * restrict stream, const wchar_t * restrict format,va_list arg);
int vfwscanf_s(FILE * restrict stream,const wchar_t * restrict format, va_list arg);
int vsnwprintf_s(wchar_t * restrict s, rsize_t n, const wchar_t * restrict format,va_list arg);
int vswprintf_s(wchar_t * restrict s, rsize_t n, const wchar_t * restrict format,va_list arg);
int vswscanf_s(const wchar_t * restrict s, const wchar_t * restrict format,va_list arg);
int vwprintf_s(const wchar_t * restrict format,va_list arg);
int vwscanf_s(const wchar_t * restrict format,va_list arg);
int wprintf_s(const wchar_t * restrict format, ...);
int wscanf_s(const wchar_t * restrict format, ...);
errno_t wcscpy_s(wchar_t * restrict s1, rsize_t s1max,const wchar_t * restrict s2);
errno_t wcsncpy_s(wchar_t * restrict s1, rsize_t s1max, const wchar_t * restrict s2,rsize_t n);
errno_t wmemcpy_s(wchar_t * restrict s1, rsize_t s1max, const wchar_t * restrict s2,rsize_t n);
errno_t wmemmove_s(wchar_t *s1, rsize_t s1max,const wchar_t *s2, rsize_t n);
errno_t wcscat_s(wchar_t * restrict s1, rsize_t s1max,const wchar_t * restrict s2);
errno_t wcsncat_s(wchar_t * restrict s1, rsize_t s1max, const wchar_t * restrict s2,rsize_t n);
size_t wcsnlen_s(const wchar_t *s, size_t maxsize);
errno_t wcrtomb_s(size_t * restrict retval, char * restrict s, rsize_t smax,wchar_t wc, mbstate_t * restrict ps);
errno_t mbsrtowcs_s(size_t * restrict retval, wchar_t * restrict dst, rsize_t dstmax, const char ** restrict src, rsize_t len,mbstate_t * restrict ps);
errno_t wcsrtombs_s(size_t * restrict retval, char * restrict dst, rsize_t dstmax, const wchar_t ** restrict src, rsize_t len,mbstate_t * restrict ps);

wctype.h

編集
Wide character classification and mapping utilities <wctype.h>
int iswalnum(wint_t wc);
int iswalpha(wint_t wc);
int iswblank(wint_t wc);
int iswcntrl(wint_t wc);
int iswdigit(wint_t wc);
int iswgraph(wint_t wc);
int iswlower(wint_t wc);
int iswprint(wint_t wc);
int iswpunct(wint_t wc);
int iswspace(wint_t wc);
int iswupper(wint_t wc);
int iswxdigit(wint_t wc);
int iswctype(wint_t wc, wctype_t desc);
wctype_t wctype(const char *property);
wint_t towlower(wint_t wc);
wint_t towupper(wint_t wc);
wint_t towctrans(wint_t wc, wctrans_t desc);
wctrans_t wctrans(const char *property);

7.33 Future library directions

編集

将来のライブラリの方向性について、以下のセクションごとに解説します。

7.33.1 Complex arithmetic <complex.h>

編集
  1. cacospi、casinpi、catanpi、ccompoundn、ccospi、cerfc、cerf、cexp10m1、cexp10、cexp2m1、cexp2、cexpm1、clgamma、clog10p1、clog10、clog1p、clog2p1、clog2、clogp1、cpown、cpowr、crootn、crsqrt、csinpi、ctanpi、ctgamma とそれらに f または l が付いた名前の関数は、将来的に complex.h ヘッダーに追加される可能性がある予約識別子です。

7.33.2 Character handling <ctype.h>

編集
  1. is または to で始まり、小文字の文字が続く関数名は、将来的に ctype.h ヘッダーに追加される可能性がある予約識別子です。

7.33.3 Errors <errno.h>

編集
  1. E と数字または大文字の文字で始まるマクロは、将来的に errno.h ヘッダーに追加される可能性があります。

7.33.4 Floating-point environment <fenv.h>

編集
  1. FE_ と大文字の文字で始まるマクロは、将来的に fenv.h ヘッダーに追加される可能性があります。

7.33.5 Characteristics of floating types <float.h>

編集
  1. DBL_、DEC32_、DEC64_、DEC128_、DEC_、FLT_、LDBL_ と大文字の文字で始まるマクロは、将来的に float.h ヘッダーに追加される可能性がある予約識別子です。
  2. DECIMAL_DIG マクロの使用は時代遅れの特徴であり、代わりに LDBL_DECIMAL_DIG などの型特有のマクロを使用することが推奨されます。
  3. FLT_HAS_SUBNORM、DBL_HAS_SUBNORM、LDBL_HAS_SUBNORM マクロの使用は時代遅れの特徴です。

7.33.6 Format conversion of integer types <inttypes.h>

編集
  1. PRI または SCN で始まり、小文字の文字、B、または X が続くマクロは、将来的に inttypes.h ヘッダーに追加される可能性がある予約識別子です。
  2. str または wcs で始まり、小文字の文字が続く関数名は、将来的に inttypes.h ヘッダーに追加される可能性がある予約識別子です。

7.33.7 Localization <locale.h>

編集
  1. LC_ と大文字の文字で始まるマクロは、将来的に locale.h ヘッダーに追加される可能性があります。

7.33.8 Mathematics <math.h>

編集
  1. FP_ と大文字の文字で始まるマクロは、将来的に math.h ヘッダーに追加される可能性があります。
  2. MATH_ と大文字の文字で始まるマクロは、将来的に math.h ヘッダーに追加される可能性がある予約識別子です。
  3. is で始まり、小文字の文字が続く関数名は、将来的に math.h ヘッダーに追加される可能性がある予約識別子です。
  4. cr_ で始まる関数名は、将来的に math.h ヘッダーに追加される可能性がある予約識別子です。cr_ プレフィックスは、正確に丸められたバージョンの関数を示すためのものです。
  5. math.h での INFINITY、DEC_INFINITY、NAN、DEC_NAN マクロの使用は時代遅れの特徴です。代わりに、これらのマクロを float.h で使用してください。

7.33.9 Signal handling <signal.h>

編集
  1. SIG と大文字の文字または SIG_ と大文字の文字で始まるマクロは、将来的に signal.h ヘッダーに追加される可能性があります。

7.33.10 Atomics <stdatomic.h>

編集
  1. ATOMIC_ と大文字の文字で始まるマクロは、将来的に stdatomic.h ヘッダーに追加される可能性がある予約識別子です。atomic_ または memory_ で始まり、小文字の文字が続く型名も同様に予約識別子です。memory_order_ で始まり、小文字の文字が続く列挙定数も stdatomic.h ヘッダーに追加される可能性があります。atomic_ で始まり、小文字の文字が続く関数名も同様に予約識別子です。

7.33.11 Boolean type and values <stdbool.h>

編集
  1. __bool_true_false_are_defined マクロの使用は時代遅れの特徴です。

7.33.12 Bit and byte utilities <stdbit.h>

編集
  1. stdc_ で始まる型名および関数名は、将来的に stdbit.h ヘッダーに追加される可能性がある予約識別子です。

7.33.13 Checked Arithmetic Functions <stdckdint.h>

編集
  1. ckd_ で始まる型名および関数名は、将来的に stdckdint.h ヘッダーに追加される可能性がある予約識別子です。

7.33.14 Integer types <stdint.h>

編集
  1. int または uint で始まり、_t で終わる型名は、将来的に stdint.h ヘッダーに追加される可能性がある予約識別子です。INT または UINT で始まり、_MAX、_MIN、_WIDTH、または _C で終わるマクロ名も同様に予約識別子です。

7.33.15 Input/output <stdio.h>

編集
  1. 小文字の文字が fprintf や fscanf の変換指定子および長さ修飾子に追加される可能性があります。他の文字は拡張に使用される場合があります。将来的には、printf の変換指定子 B が必須になる可能性があります。
  2. ungetc をバイナリストリームでファイル位置インジケータがゼロのときに使用することは、時代遅れの特徴です。

7.33.16 General utilities <stdlib.h>

編集
  1. str または wcs で始まり、小文字の文字が続く関数名は、将来的に stdlib.h ヘッダーに追加される可能性がある予約識別子です。
  2. 実際の関数にアクセスするために bsearch のマクロ定義を抑制することは、時代遅れの特徴です。

7.33.17 String handling <string.h>

編集
  1. str、mem、または wcs で始まり、小文字の文字が続く関数名は、将来的に string.h ヘッダーに追加される可能性がある予約識別子です。
  2. 実際の関数にアクセスするために memchr、strchr、strpbrk、strrchr、または strstr のマクロ定義を抑制することは、時代遅れの特徴です。

7.33.18 Date and time <time.h>

編集
  1. TIME_ と大文字の文字で始まるマクロは、将来的に time.h ヘッダーに追加される可能性があります。
  2. TIME_MONOTONIC、TIME_ACTIVE、および TIME_THREAD_ACTIVE の時間基準は、将来的にこの標準の必須要件となる可能性があります。

7.33.19 Threads <threads.h>

編集
  1. cnd_、mtx_、thrd_、または tss_ で始まり、小文字の文字が続く関数名、型名、および列挙定数は、将来的に threads.h ヘッダーに追加される可能性がある予約識別子です。

7.33.20 Extended multibyte and wide character utilities <wchar.h>

編集
  1. wcs で始まり、小文字の文字が続く関数名は、将来的に wchar.h ヘッダーに追加される可能性がある予約識別子です。
  2. 小文字の文字が fwprintf および fwscanf の変換指定子および長さ修飾子に追加される可能性があります。他の文字は拡張に使用される場合があります。
  3. 実際の関数にアクセスするために wcschr、wcspbrk、wcsrchr、wmemchr、または wcsstr のマクロ定義を抑制することは、時代遅れの特徴です。

7.33.21 Wide character classification and mapping utilities <wctype.h>

編集
  1. is または to で始まり、小文字の文字が続く関数名は、将来的に wctype.h ヘッダーに追加される可能性がある予約識別子です。

脚註

編集
  1. ^ N1570 Committee Draft — April 12, 2011 ISO/IEC 9899:201x. ISO/IEC. p. 180, §7. Library. http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf. 
  2. ^ N1570 Committee Draft — April 12, 2011 ISO/IEC 9899:201x. ISO/IEC. p. 177, §6.10.8.3 Conditional feature macros. http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf. 
  3. ^ N1570 Committee Draft — April 12, 2011 ISO/IEC 9899:201x. ISO/IEC. p. 583, §K.3.1.1 Standard headers. http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf. 
  4. ^ N1570 Committee Draft — April 12, 2011 ISO/IEC 9899:201x. ISO/IEC. p. 162, §6.10.1 Conditional inclusion. http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf. "all remaining identifiers (including those lexically identical to keywords) are replaced with the pp-number 0, and then each preprocessing token is converted into a token." 
  5. ^ 未定義マクロが 0 とみなされるC言語の使用はは、ミススペル（典型的には _ の数の間違え）で本体は 1 なマクロが 0 とみなされる発見困難なバグに繋がります。clang や gcc であればコマンドラインから -Wundef を指定することで未定義マクロの参照を警告させることが出来ます（-Wallでは、-Wundefが有効にならないことに注意してください）。
  6. ^ [open-std.org/jtc1/sc22/wg14/www/docs/n2596.pdf ISO/IEC 9899:202x (E) working draft — December 11, 2020 N2596]. ISO/IEC. p. 445, §F.5 Conversions between binary floating types and decimal character sequences. open-std.org/jtc1/sc22/wg14/www/docs/n2596.pdf. 
  7. ^ <limits.h>は、C99では"Sizes of integer types"、JISCでは、"整数型の大きさ" でしたが、C23では"Characteristics of integer types"となったので、<float.h>の/Characteristics of floating types/浮動小数点型の特性/ にならって "整数の特性" の訳をあてました
  8. ^ N1570 Committee Draft — April 12, 2011 ISO/IEC 9899:201x. ISO/IEC. p. 268, §7.15 Alignment <stdalign.h>. http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf. 
  9. ^ N1570 Committee Draft — April 12, 2011 ISO/IEC 9899:201x. ISO/IEC. p. 273, §7.17 Atmics <stdatomic.h>. http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf. 
  10. ^ N3054 working draft — September 3, 2022 ISO/IEC 9899:2023 (E). ISO/IEC. (2022-09-03). p. 314,§ 7.20 Checked Integer Arithmetic. https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3054.pdf. 
  11. ^ N3054 working draft — September 3, 2022 ISO/IEC 9899:2023 (E). ISO/IEC. (2022-09-03). p. 305,§ 7.18 Bit and byte utilities. https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3054.pdf. 
  12. ^ N1570 Committee Draft — April 12, 2011 ISO/IEC 9899:201x. ISO/IEC. p. 361, §7.23 _Noreturn <stdnoreturn.h>. http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf. 
  13. ^ N1570 Committee Draft — April 12, 2011 ISO/IEC 9899:201x. ISO/IEC. p. 376, §7.26 Threads <threads.h>. http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf. 
  14. ^ N1570 Committee Draft — April 12, 2011 ISO/IEC 9899:201x. ISO/IEC. p. 398, §7.28 Unicode utilities <uchar.h>. http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf. 
"https://ja.wikibooks.org/w/index.php?title=C言語/標準ライブラリ&oldid=271071" より作成