C provides a family of functions for parsing character sequences as strings and numbers:

#include <stdio.h>
int scanf(const char *fmt, ...);
int fscanf(FILE *in, const char *fmt, ...);
int sscanf(const char *buf, const char *fmt, ...);

#include <stdarg.h>
int vscanf(const char *fmt, va_list va);
int vfscanf(FILE *in, const char *fmt, va_list va);
int vsscanf(const char *buf, const char *fmt, va_list va);

#include <wchar.h>
int wscanf(const wchar_t *fmt, ...);
int swscanf(const wchar_t *buf, const wchar_t *fmt, ...);

#include <stdarg.h>
int vwscanf(const wchar_t *fmt, va_list va);
int vswscanf(const wchar_t *buf, const wchar_t *fmt, va_list va);

#include <stdio.h>
#include <wchar.h>
int fwscanf(FILE *in, const wchar_t *fmt, ...);

#include <stdarg.h>
int vfwscanf(FILE *in, const wchar_t *fmt, va_list va);

#define __STDC_WANT_LIB_EXT1__ 1
#include <stdio.h>
int scanf_s(const char *fmt, ...);
int fscanf_s(FILE *in, const char *fmt, ...);
int sscanf_s(const char *buf, const char *fmt, ...);

#include <stdarg.h>
int vscanf_s(const char *fmt, va_list va);
int vfscanf_s(FILE *in, const char *fmt, va_list va);
int vsscanf_s(const char *buf, const char *fmt, va_list va);

#define __STDC_WANT_LIB_EXT1__ 1
#include <wchar.h>
int wscanf_s(const wchar_t *fmt, ...);
int swscanf_s(const wchar_t *buf, const wchar_t *fmt, ...);

#include <stdarg.h>
int vwscanf_s(const wchar_t *fmt, va_list va);
int vswscanf_s(const wchar_t *buf, const wchar_t *fmt, va_list va);

#define __STDC_WANT_LIB_EXT1__ 1
#include <stdio.h>
#include <wchar.h>
int fwscanf_s(FILE *in, const wchar_t *fmt, ...);

#include <stdarg.h>
int vfwscanf_s(FILE *in, const wchar_t *fmt, va_list va);

Each function takes a format string fmt and a variable number of pointer arguments in one form or another, which are consumed in sequence according to the format string. It also has a defined input source, which may be an open stream or a character array. Each function consumes characters from the source, and matches them in succession against characters in the format string. It stops when it fails to match the source against the format string, leaving the failed characters in the source. The number of converted and assigned arguments is returned, or -1 on error.

The format string may contain substrings called conversion specifiers, which match sets of patterns according to the parameters contained within the specifier. If the next characters in the source match one of the patterns, they are consumed from the source, and converted into a value. An argument is also consumed, and interpreted as a pointer to a variable, then the converted value is assigned to the variable. The number of successful assignments is returned.

One or more adjacent white-space characters in the format string match and consume one or more white-space characters in the source. Other characters that are not part of conversion specifiers must match the source exactly.

Each conversion specifier begins with % (U+0025), and continues with an optional flag *, then an optional integer field width, then an optional type modifier (one of "hh", "h", "l", "ll", "j", "z", "t" and "L"), and finally a format code (one of "d", "i", "u", "o", "x", "X", "a", "A", "e", "E", "f", "F", "g", "G", "c", "s", "p" and "n").

The * flag prevents an argument from being consumed, so no assignment takes place. The field width limits the number of source characters that may be consumed to make the conversion.

These functions return EOF if an error occurs before the first conversion is completed.

Twenty-four functions exist because C does not support any name overloading, yet there are many independent options that must be selected. The form of the name is {v}{f,s}{w}scanf{_s}.

• The first part v indicates that the argument list is supplied as a va_list given as the last argument. Without v, the function is declared with ... at the end of its parameter list, so arguments are given directly.

• The second part f,s,sn selects the input.

  • s indicates that characters are to be read from an array, until a null terminator. The first argument buf is a pointer to the first element to be read from.
  • f indicates that characters are to be read from a stream, FILE *fp, which is given as the first argument. The function stops reading at end-of-file.
  • Functions with none of these prefixes read from the standard input stream, stdin.

• The third part w indicates that the function operates on wide characters. The format string is a null-terminated array of wchar_t. s functions read from arrays of wchar_t. f functions are wide-oriented.

  Without w, the function operates on multibyte characters. The format string is a null-terminated array of char. s functions read from arrays of char. f functions are byte-oriented.

• _s functions apply additional bounds checking, and fail on other constraint violations:

  • %n as a conversion specifier;
  • NULL as an argument corresponding to any conversion specifier.