C言語/標準ライブラリ

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

用語定義編集

C言語の規格 ISO/IEC 9899:2011(通称C11)の§7. Library §7.1 Introduction §7.1.1 Definitions of terms に用語定義が有り短いので引用/和訳しました[2]

文字列( string )とは、最初のヌル文字で終わり、それを含む連続した文字の並びのことです。 マルチバイト文字列( multibyte string )という用語は、文字列に含まれるマルチバイト文字に対する特別な処理を強調したり、ワイド文字列との混同を避けるために使われることがあります。 文字列へのポインタ( A pointer to a string )は、その最初の(アドレスが最も低い)文字へのポインタです。 文字列の長さ( The length of a string )は、NULL文字の前のバイト数であり、文字列の値は、含まれる文字の値を順に並べたものです。 文字列の値( the value of a string )は、含まれる文字の値を順番に並べたものです。

小数点の文字( The decimal-point character )とは、浮動小数点数を文字列に変換する関数が、その文字列の小数部分の先頭を示すために使用する文字です。 本文中および例題ではピリオドで表現されているが,setlocale関数で変更可能です(編註: ヨーロッパの多くの国では小数点に '.' ではなく ',' が使われ、3桁ごとの区切りに '.' が使われます)。

ヌルワイド文字( A null wide character )とは、コード値がゼロのワイド文字のことです。

ワイド文字列( A wide string )とは、最初のヌルワイド文字で終了し、それを含むワイド文字の連続したシーケンスである。 ワイド文字列へのポインタ( A pointer to a wide string )は、その最初の(アドレスが最も低い)ワイド文字へのポインタです。 ワイド文字列の長さ( The length of a wide string )は、ヌルワイド文字の前にあるワイド文字の数です。 ワイド文字列の値( The value of a wide string )は、含まれるワイド文字のコード値を順番に並べたものです。

シフトシーケンス( shift sequence )とは、マルチバイト文字列の中で、シフトの状態を変化させる(可能性のある)連続したバイト列のことです。シフトシーケンスには、対応するワイド文字があってはならない。 その代わりに、隣接するマルチバイト文字の補助的な役割を果たすものとする。 本節では、"white-space character"(空白文字?[3]) という表現は、isspaceで定義された(実行)white-space characterを指す。 また、"white-space wide character"(ワイド空白文字?) という表現は、iswspaceで定義された(実行)white-space wide characterを指す。

条件付き機能マクロ編集

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

数学ライブラリー 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__ によって制御するようになりました[5]__STDC_WANT_LIB_EXT1__は利用者が定義するもので、境界検査インターフェースを宣言している標準ヘッダーファイルをインクルードする前に定義を行います。 __STDC_WANT_LIB_EXT1__を 1 に定義すると境界検査インターフェースの使用を求め、0 に定義すると境界検査インターフェースの使用を求めない意味になります。 ANSI C 以降では未定義のマクロの値は 0 とみなされる[6][7]ので、__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として知られる浮動小数点算術に関する標準)の機能の要求を制御する予定です[8]


標準ライブラリのヘッダーファイル一覧編集

トーク: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);

脚註編集

  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. 180, §7.1.1 Definitions of terms. http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf. 
  3. ^ white-space character及びwhite-space wide characterは名前に反して改行の制御コードを含むので、空白文字の訳を充てることを躊躇した。
  4. ^ 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. 
  5. ^ 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. 
  6. ^ 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." 
  7. ^ 未定義マクロが 0 とみなされるC言語の使用はは、ミススペル(典型的には _ の数の間違え)で本体は 1 なマクロが 0 とみなされる発見困難なバグに繋がります。clang や gcc であればコマンドラインから -Wundef を指定することで未定義マクロの参照を警告させることが出来ます(-Wallでは、-Wundefが有効にならないことに注意してください)。
  8. ^ [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. 
  9. ^ <limits.h>は、C99では"Sizes of integer types"、JISCでは、"整数型の大きさ" でしたが、C23では"Characteristics of integer types"となったので、<float.h>の/Characteristics of floating types/浮動小数点型の特性/ にならって "整数の特性" の訳をあてました
  10. ^ 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. 
  11. ^ 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. 
  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.