User:Apenguinlover/sandbox
scanf
[edit | edit source] This page may need to verify facts by citing reliable publications. You can help by adding references to reliable publications, or by correcting statements cited as fact. |
scanf is a function that reads data with specified format from stdin
, originated from C programming language, likely standing for "scan format"
The scanf
function prototype is:
int scanf(const char *format, ...);
The function returns the total number of items successfully matched, which can be less than the number requested. If the input stream is exhausted or reading from it otherwise fails before any items are matched, EOF is returned[1].
Usage
[edit | edit source]The scanf
function is found in C, in which it reads input for numbers and other datatypes from standard input (often a command line interface or similar kind of a text user interface).
The following shows code in C that reads a variable number of unformatted decimal integers from the standard input and prints out each of them on a separate line:
#include <stdio.h>
int
main(void)
{
int n;
while (scanf("%d", & n))
printf("%d\n", n);
return 0;
}
After being processed by the program above, a messy list of integers such as
456 123 789 456 12 456 1 2378
will appear neatly as:
456 123 789 456 12 456 1 2378
To print out a word:
#include <stdio.h>
int
main(void)
{
char word[20];
if(scanf("%19s", word) == 1)
puts(word);
return 0;
}
No matter what the datatype the programmer wants the program to read, the arguments (such as &n
above) must be pointers pointing to memory. Otherwise, the function will not perform correctly because it will be attempting to overwrite the wrong sections of memory, rather than pointing to the memory location of the variable you are attempting to get input for.
As scanf
is designated to read only from standard input, some programming languages with interfaces, such as PHP, have derivatives such as sscanf
and fscanf
but not scanf
itself[2].
Derivatives
[edit | edit source]Depending on the actual source of input, programmers can use different derivatives of scanf
. Two common examples are sscanf
and fscanf
.
fscanf
[edit | edit source]The fscanf derivative reads input from a specified file stream. The prototypes are as follows:
(C or C++)
int fscanf (FILE *file, const char *format, ...);
The fscanf
derivative works like the original scanf
function - parts of the input, once read, will not be read again until the file is closed and reopened.
sscanf
[edit | edit source]The sscanf derivative reads input from a character string passed as the first argument. One important different from fscanf is that the string is read from the beginning every time the function is called. There is no 'pointer' that is incremented upon a successful read operation. The prototypes are as follows:
(C or C++)
int sscanf (const char *str, const char *format, ...);
vscanf, vsscanf, and vfscanf
[edit | edit source]int vscanf (const char *format, va_list args);
int vsscanf (const char *source, const char *format, va_list args);
int vfscanf (FILE *file, const char *format, va_list args);
These are like the same functions without the v
prefix, except they take their arguments from a va_list
. (See stdarg.h.) These variants may be used in variable-argument functions.
Format string specifications
[edit | edit source]The formatting placeholders in scanf
are more or less the same as that in printf
, its reverse function.
There are rarely constants (i.e. characters that are not formatting placeholders) in a format string, mainly because a program is usually not designed to read known data. The exception is one or more whitespace characters, which discards all whitespace characters in the input.
Some of the most commonly used placeholders follow:
%d
: Scan an integer as a signed decimal number.%i
: Scan an integer as a signed number. Similar to%d
, but interprets the number as hexadecimal when preceded by0x
and octal when preceded by0
. For example, the string031
would be read as 31 using%d
, and 25 using%i
. The flagh
in%hi
indicates conversion to ashort
andhh
conversion to achar
.%u
: Scan for decimalunsigned int
(Note that in the C99 standard the input value minus sign is optional, so if a negative[clarification needed] number is read, no errors will arise and the result will be the two's complement. Seestrtoul()
.Template:Failed verification) Correspondingly,%hu
scans for anunsigned short
and%hhu
for anunsigned char
.%f
: Scan a floating-point number in normal (fixed-point) notation.%g
,%G
: Scan a floating-point number in either normal or exponential notation.%g
uses lower-case letters and%G
uses upper-case.%x
,%X
: Scan an integer as an unsigned hexadecimal number.%o
: Scan an integer as an octal number.%s
: Scan a character string. The scan terminates at whitespace. A null character is stored at the end of the string, which means that the buffer supplied must be at least one character longer than the specified input length.%c
: Scan a character (char). No null character is added.(space)
: Space scans for whitespace characters.%lf
: Scan as a double floating-point number.%Lf
: Scan as a long double floating-point number.
The above can be used in compound with numeric modifiers and the l
, L
modifiers which stand for "long" in between the percent symbol and the letter. There can also be numeric values between the percent symbol and the letters, preceding the long
modifiers if any, that specifies the number of characters to be scanned. An optional asterisk (*
) right after the percent symbol denotes that the datum read by this format specifier is not to be stored in a variable. No argument behind the format string should be included for this dropped variable.
The ff
modifier in printf is not present in scanf, causing differences between modes of input and output. The ll
and hh
modifiers are not present in the C90 standard, but are present in the C99 standard.[3]
An example of a format string is
"%7d%s %c%lf"
The above format string scans the first seven characters as a decimal integer, then reads the remaining as a string until a space, new line or tab is found, then scans the first non-whitespace character following and a double-precision floating-point number afterwards.
Error handling
[edit | edit source]scanf
is usually used in situations when the program cannot guarantee that the input is in the expected format. Therefore a robust program must check whether the scanf
call succeeded and take appropriate action. If the input was not in the correct format, the erroneous data will still be on the input stream and must be read and discarded before new input can be read. An alternative method of reading input, which avoids this, is to use fgets
and then examine the string read in. The last step can be done by sscanf
, for example.
Security
[edit | edit source]Like printf
, scanf
is vulnerable to format string attacks. Great care should be taken to ensure that the formatting string includes limitations for string and array sizes. In most cases the input string size from a user is arbitrary; it can not be determined before the scanf
function is executed. This means that uses of %s
placeholders without length specifiers are inherently insecure and exploitable for buffer overflows. Another potential problem is to allow dynamic formatting strings, for example formatting strings stored in configuration files or other user controlled files. In this case the allowed input length of string sizes can not be specified unless the formatting string is checked beforehand and limitations are enforced. Related to this are additional or mismatched formatting placeholders which do not match the actual vararg list. These placeholders might be partially extracted from the stack, contain undesirable or even insecure pointers depending on the particular implementation of varargs.