scanf - Read Data

Syntax

#include <stdio.h>
int scanf(const char *format-string, argument-list);

scanf reads data from the standard input stream stdin into the locations given by each entry in argument-list. Each argument must be a pointer to a variable with a type that corresponds to a type specifier in format-string. The format-string controls the interpretation of the input fields.

The format-string can contain one or more of the following:

White-space characters, as specified by isspace (such as blanks and new-line characters). A white-space character causes scanf to read, but not to store, all consecutive white-space characters in the input up to the next character that is not white space. One white-space character in format-string matches any combination of white-space characters in the input.
Characters that are not white space, except for the percent sign character (%). A non-white-space character causes scanf to read, but not to store, a matching non-white-space character. If the next character in stdin does not match, scanf ends.
Format specifications, introduced by the percent sign (%). A format specification causes scanf to read and convert characters in the input into values of a specified type. The value is assigned to an argument in the argument list.

scanf reads format-string from left to right. Characters outside of format specifications are expected to match the sequence of characters in stdin; the matched characters in stdin are scanned but not stored. If a character in stdin conflicts with format-string, scanf ends. The conflicting character is left in stdin as if it had not been read.

When the first format specification is found, the value of the first input field is converted according to the format specification and stored in the location specified by the first entry in argument-list. The second format specification converts the second input field and stores it in the second entry in argument-list, and so on through the end of format-string.

An input field is defined as all characters up to the first white-space character (space, tab, or new line), up to the first character that cannot be converted according to the format specification, or until the field width is reached, whichever comes first. If there are too many arguments for the format specifications, the extra arguments are ignored. The results are undefined if there are not enough arguments for the format specifications.

A format specification has the following form: кФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФПГ Г
Г >>ФФ%ФФТФФФФТФФТФФФТФФТФФФФФФФТФФТФФФТФФtypeФФ>< Г
Г РФn$Фй РФ*Фй РФwidthФй УФhФД Г
Г УФlФД Г
Г РФLФй Г
Г Г
РФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФФй

In the format specification above, %n$ specifies the nth argument.

Each field of the format specification is a single character or a number signifying a particular format option. The type character, which appears after the last optional format field, determines whether the input field is interpreted as a character, a string, or a number. The simplest format specification contains only the percent sign and a type character (for example, %s). Each field of the format specification is discussed in detail below.

An asterisk (*) following the percent sign suppresses assignment of the next input field, which is interpreted as a field of the specified type. The field is scanned but not stored.

The width is a positive decimal integer controlling the maximum number of characters to be read from stdin. No more than width characters are converted and stored at the corresponding argument. Fewer than width characters are read if a white-space character (space, tab, or new line), or a character that cannot be converted according to the given format occurs before width is reached.

The optional prefix l shows that you use the long version of the following type, while the prefix h indicates that the short version is to be used. The corresponding argument should point to a long or double object (for the l character), a long double object (for the L character), or a short object (with the h character). The l and h modifiers can be used with the d, i, o, x, and u type characters. The l modifier can also be used with the e, f, and g type characters. The L modifier can be used with the e, f and g type characters. The l and h modifiers are ignored if specified for any other type. Note that the l modifier is also used with the c and s characters to indicate a multibyte character or string.

The type characters and their meanings are in the following table: кФФФФФФФФФТФФФФФФФФФФФФФФФФФФФФФФФФФФФФФТФФФФФФФФФФФФФФФФФФФФФФФФФФФФП
Г Char- Г Type of Input Expected. Г Type of Argument. Г
Г acter Г Г Г
УФФФФФФФФФХФФФФФФФФФФФФФФФФФФФФФФФФФФФФФХФФФФФФФФФФФФФФФФФФФФФФФФФФФФД
Г "d" Г Decimal integer. Г Pointer to INT. Г
УФФФФФФФФФХФФФФФФФФФФФФФФФФФФФФФФФФФФФФФХФФФФФФФФФФФФФФФФФФФФФФФФФФФФД
Г "o" Г Octal integer. Г Pointer to UNSIGNED INT. Г
УФФФФФФФФФХФФФФФФФФФФФФФФФФФФФФФФФФФФФФФХФФФФФФФФФФФФФФФФФФФФФФФФФФФФД
Г "x", Г Hexadecimal integer. Г Pointer to UNSIGNED INT. Г
Г "X" Г Г Г
УФФФФФФФФФХФФФФФФФФФФФФФФФФФФФФФФФФФФФФФХФФФФФФФФФФФФФФФФФФФФФФФФФФФФД
Г "i" Г Decimal, hexadecimal, or Г Pointer to INT. Г
Г Г octal integer. Г Г
УФФФФФФФФФХФФФФФФФФФФФФФФФФФФФФФФФФФФФФФХФФФФФФФФФФФФФФФФФФФФФФФФФФФФД
Г "u" Г Unsigned decimal integer. Г Pointer to UNSIGNED INT. Г
УФФФФФФФФФХФФФФФФФФФФФФФФФФФФФФФФФФФФФФФХФФФФФФФФФФФФФФФФФФФФФФФФФФФФД
Г "e, f, Г Floating-point value con- Г Pointer to FLOAT. Г
Г g" Г sisting of an optional sign Г Г
Г Г (+ or -); a series of one Г Г
Г "E, G" Г or more decimal digits pos- Г Г
Г Г sibly containing a decimal Г Г
Г Г point; and an optional Г Г
Г Г exponent (e or E) followed Г Г
Г Г by a possibly signed Г Г
Г Г integer value. Г Г
УФФФФФФФФФХФФФФФФФФФФФФФФФФФФФФФФФФФФФФФХФФФФФФФФФФФФФФФФФФФФФФФФФФФФД
Г "c" Г Sequence of bytes; white- Г Pointer to CHAR large Г
Г Г space characters that are Г enough for input field. Г
Г Г ordinarily skipped are read Г Г
Г Г when "c" is specified. Г Г
УФФФФФФФФФХФФФФФФФФФФФФФФФФФФФФФФФФФФФФФХФФФФФФФФФФФФФФФФФФФФФФФФФФФФД
Г "lc, C" Г Multibyte characters. The Г Pointer to wchar_t large Г
Г Г multibyte characters are Г enough for input field. Г
Г Г converted to wide charac- Г Г
Г Г ters as if by a call to Г Г
Г Г mbstowcs. The field width Г Г
Г Г specifies the number of Г Г
Г Г wide characters matched; if Г Г
Г Г no width is specified, one Г Г
Г Г multibyte character is Г Г
Г Г matched. Г Г
УФФФФФФФФФХФФФФФФФФФФФФФФФФФФФФФФФФФФФФФХФФФФФФФФФФФФФФФФФФФФФФФФФФФФД
Г "s" Г Sequence of bytes that do Г Pointer to char array Г
Г Г not include white space. Г large enough for input Г
Г Г Г field plus a terminating Г
Г Г Г null character ("\0"), Г
Г Г Г which is automatically Г
Г Г Г appended. Г
УФФФФФФФФФХФФФФФФФФФФФФФФФФФФФФФФФФФФФФФХФФФФФФФФФФФФФФФФФФФФФФФФФФФФД
Г "ls, S" Г Multibyte string. None of Г Pointer to wchar_t array Г
Г Г the characters can be Г large enough for the input Г
Г Г single-byte white-space Г field and the terminating Г
Г Г characters (as specified by Г null wide character Г
Г Г the isspace function). Г ("L\0"), which is added Г
Г Г Each multibyte character in Г automatically. Г
Г Г the sequence is converted Г Г
Г Г to a wide character as if Г Г
Г Г by a call to mbstowcs. Г Г
УФФФФФФФФФХФФФФФФФФФФФФФФФФФФФФФФФФФФФФФХФФФФФФФФФФФФФФФФФФФФФФФФФФФФД
Г "n" Г No input read from stream Г Pointer to INT into which Г
Г Г or buffer. Г is stored the number of Г
Г Г Г characters successfully Г
Г Г Г read from the stream or Г
Г Г Г buffer up to that point in Г
Г Г Г the call to scanf. Г
УФФФФФФФФФХФФФФФФФФФФФФФФФФФФФФФФФФФФФФФХФФФФФФФФФФФФФФФФФФФФФФФФФФФФД
Г "p" Г Pointer to "void" converted Г Pointer to "void". Г
Г Г to series of characters. Г Г
РФФФФФФФФФСФФФФФФФФФФФФФФФФФФФФФФФФФФФФФСФФФФФФФФФФФФФФФФФФФФФФФФФФФФй

To read strings not delimited by space characters, substitute a set of characters in brackets ([ ]) for the s (string) type character. The corresponding input field is read up to the first character that does not appear in the bracketed character set. If the first character in the set is a caret (^), the effect is reversed: the input field is read up to the first character that does appear in the rest of the character set.

To store a string without storing an ending null character (\0), use the specification %ac, where a is a decimal integer. In this instance, the c type character means that the argument is a pointer to a character array. The next number of characters is read from the input stream into the specified location, and no null character is added.

The input for a %x format specifier is interpreted as a hexadecimal number.

scanf scans each input field character by character. It might stop reading a particular input field either before it reaches a space character, when the specified width is reached, or when the next character cannot be converted as specified. When a conflict occurs between the specification and the input character, the next input field begins at the first unread character. The conflicting character, if there was one, is considered unread and is the first character of the next input field or the first character in subsequent read operations on stdin.

scanf returns the number of fields that were successfully converted and assigned. The return value does not include fields that were read but not assigned.

The return value is EOF for an attempt to read at end-of-file if no conversion was performed. A return value of 0 means that no fields were assigned.

#include <stdio.h>

int main(void)
{
   int i;
   float fp;
   char c,s[81];

   printf("Enter an integer, a real number, a character and a string : \n");
   if (scanf("%d %f %c %s", &i, &fp, &c, s) != 4)
      printf("Not all of the fields were assigned\n");
   else {
      printf("integer = %d\n", i);
      printf("real number = %f\n", fp);
      printf("character = %c\n", c);
      printf("string = %s\n", s);
   }
   return 0;

   /****************************************************************************
      The output should be similar to:

      Enter an integer, a real number, a character and a string :
      12 2.5 a yes
      integer = 12
      real number = 2.500000
      character = a
      string = yes
   ****************************************************************************/
}

This example converts a hexadecimal integer to a decimal integer. The while loop ends if the input value is not a hexadecimal integer.

#include <stdio.h>

int main(void)
{
   int number;

   printf("Enter a hexadecimal number or anything else to quit:\n");
   while (scanf("%x", &number)) {
      printf("Hexadecimal Number = %x\n", number);
      printf("Decimal Number     = %d\n", number);
   }
   return 0;

   /****************************************************************************
      The output should be similar to:

      Enter a hexadecimal number or anything else to quit:
      0x231
      Hexadecimal Number = 231
      Decimal Number     = 561
      0xf5e
      Hexadecimal Number = f5e
      Decimal Number     = 3934
      0x1
      Hexadecimal Number = 1
      Decimal Number     = 1
      q
   ****************************************************************************/
}

[Back]

[Next]