From WikiChip
Standard Functions - C
< c

C Standards

Standard Revisions

Technical Reports

Other

v · d · e

Below is a list of standard c functions which includes C89, C99, and C11 functions. This list includes function-like macros as well.

<assert.h>[edit]

  • void assert(scalar expression);

<complex.h>[edit]

  • 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>[edit]

  • 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);

<fenv.h>[edit]

  • 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);

<inttypes.h>[edit]

  • 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);

<locale.h>[edit]

  • char *setlocale(int category, const char *locale);
  • struct lconv *localeconv(void);

<math.h>[edit]

  • 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 doubledouble 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, longdouble pow(double x, double y);
  • float powf(float x, float y);
  • long double powl(long double x, longdouble 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>[edit]

  • int setjmp(jmp_buf env);
  • _Noreturn void longjmp(jmp_buf env, int val);

<signal.h>[edit]

  • void (*signal(int sig, void (*func)(int)))(int);
  • int raise(int sig);

<stdarg.h>[edit]

  • 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>[edit]

  • 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);

<stdio.h>[edit]

  • int remove(const char *filename);
  • int rename(const char *old, const char *new);
  • FILE *tmpfile(void);
  • char *tmpnam(char *s);
  • int fclose(FILE *stream);
  • int fflush(FILE *stream);
  • FILE *fopen(const char * restrict filename, const char * restrict mode);
  • FILE *freopen(const char * restrict filename, const char * restrict mode, FILE * restrict 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);
  • char *fgets(char * restrict s, int n, FILE * restrict 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);
  • char *gets_s(char *s, rsize_t n);
  • 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 *aligned_alloc(size_t alignment, size_t size);
  • void *calloc(size_t nmemb, size_t size);
  • void free(void *ptr);
  • void *malloc(size_t size);
  • void *realloc(void *ptr, size_t size);
  • _Noreturn void abort(void);
  • int atexit(void (*func)(void));
  • int at_quick_exit(void (*func)(void));
  • _Noreturn void exit(int status);
  • _Noreturn void _Exit(int status);
  • char *getenv(const char *name);
  • _Noreturn void quick_exit(int status);
  • int system(const char *string);
  • void *bsearch(const void *key, const void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *));
  • void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *));
  • 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);
  • void *bsearch_s(const void *key, const void *base, rsize_t nmemb, rsize_t size, int (*compar)(const void *k, const void *y, void *context), void *context);
  • errno_t qsort_s(void *base, rsize_t nmemb, rsize_t size, int (*compar)(const void *x, const void *y, void *context), void *context);
  • 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);

<string.h>[edit]

  • void *memcpy(void * restrict s1, const void * restrict s2, size_t n);
  • void *memmove(void *s1, const void *s2, size_t n);
  • char *strcpy(char * restrict s1, const char * restrict s2);
  • char *strncpy(char * restrict s1, const char * restrict s2, size_t n);
  • char *strcat(char * restrict s1, const char * restrict s2);
  • char *strncat(char * restrict s1, const char * restrict s2, size_t n);
  • 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);
  • void *memchr(const void *s, int c, size_t n);
  • char *strchr(const char *s, int c);
  • size_t strcspn(const char *s1, const char *s2);
  • char *strpbrk(const char *s1, const char *s2);
  • char *strrchr(const char *s, int c);
  • size_t strspn(const char *s1, const char *s2);
  • char *strstr(const char *s1, const char *s2);
  • char *strtok(char * restrict s1, const char * restrict s2);
  • void *memset(void *s, int c, size_t n);
  • char *strerror(int errnum);
  • 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);
  • char *strtok_s(char * restrict s1, rsize_t * restrict s1max, const char * restrict s2, char ** restrict ptr);
  • errno_t memset_s(void *s, rsize_t smax, int c, 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);

<threads.h>[edit]

  • void call_once(once_flag *flag, void (*func)(void));
  • 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);
  • void *tss_get(tss_t key);
  • int tss_set(tss_t key, void *val);

<time.h>[edit]

  • 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);
  • char *asctime(const struct tm *timeptr);
  • char *ctime(const time_t *timer);
  • struct tm *gmtime(const time_t *timer);
  • struct tm *localtime(const time_t *timer);
  • 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);
  • struct tm *gmtime_s(const time_t * restrict timer, struct tm * restrict result);
  • struct tm *localtime_s(const time_t * restrict timer, struct tm * restrict result);

<uchar.h>[edit]

  • 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>[edit]

  • 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);
  • wchar_t *fgetws(wchar_t * restrict s, int n, FILE * restrict 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);
  • wchar_t *wcscpy(wchar_t * restrict s1, const wchar_t * restrict s2);
  • wchar_t *wcsncpy(wchar_t * restrict s1, const wchar_t * restrict s2, size_t n);
  • wchar_t *wmemcpy(wchar_t * restrict s1, const wchar_t * restrict s2, size_t n);
  • wchar_t *wmemmove(wchar_t *s1, const wchar_t *s2, size_t n);
  • wchar_t *wcscat(wchar_t * restrict s1, const wchar_t * restrict s2);
  • wchar_t *wcsncat(wchar_t * restrict s1, const wchar_t * restrict s2, size_t n);
  • 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);
  • wchar_t *wcschr(const wchar_t *s, wchar_t c);
  • size_t wcscspn(const wchar_t *s1, const wchar_t *s2);
  • wchar_t *wcspbrk(const wchar_t *s1, const wchar_t *s2);
  • wchar_t *wcsrchr(const wchar_t *s, wchar_t c);
  • size_t wcsspn(const wchar_t *s1, const wchar_t *s2);
  • wchar_t *wcsstr(const wchar_t *s1, const wchar_t *s2);
  • wchar_t *wcstok(wchar_t * restrict s1, const wchar_t * restrict s2, wchar_t ** restrict ptr);
  • wchar_t *wmemchr(const wchar_t *s, wchar_t c, size_t n);
  • size_t wcslen(const wchar_t *s);
  • wchar_t *wmemset(wchar_t *s, wchar_t c, size_t n);
  • 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_tconst 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)
  • 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);
  • wchar_t *wcstok_s(wchar_t * restrict s1, rsize_t * restrict s1max, const wchar_t * restrict s2, wchar_t ** restrict ptr);
  • 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>[edit]

  • 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);