还有就是*加在任何项的前面表示该项不符值，别的就没什么好说的了

Read formatted data from the standard input stream.

int scanf(
   const char* format [,argument]...
);

int wscanf(
   const wchar_t* format [,argument]...
);
Parameters
format
Format control string.
argument
Optional arguments.
Return Values
Both scanf and wscanf return the number of fields converted and assigned; the return value does not include fields that were read but not assigned.

A return value of 0 indicates that no fields were assigned.

The return value is EOF for an error or if the end-of-file character or the end-of-string character is encountered in the first attempt to read a character.

Remarks
The scanf function reads data from the standard input stream stdin and writes the data into the location given by argument.

Each argument must be a pointer to a variable of a type that corresponds to a type specifier in format.

If copying takes place between strings that overlap, the behavior is undefined.

The information here applies to the entire scanf family of functions, including the secure versions and describes the symbols used to tell the scanf functions how to parse the input stream, such as the input stream stdin for scanf, into values that are inserted into program variables.

A format specification has the following form:

% [width] [{h | l | ll | I64 | L}]type

The format argument specifies the interpretation of the input and can contain one or more of the following:

White-space characters: blank (' '); tab ('\t'); or newline ('\n'). A white-space character causes scanf to read, but not store, all consecutive white-space characters in the input up to the next non–white-space character. One white-space character in the format matches any number (including 0) and combination of white-space characters in the input.

Non–white-space characters, except for the percent sign (%). A non–white-space character causes scanf to read, but not store, a matching non–white-space character. If the next character in the input stream does not match, scanf terminates.

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.

The format is read from left to right. Characters outside format specifications are expected to match the sequence of characters in the input stream; the matching characters in the input stream are scanned but not stored. If a character in the input stream conflicts with the format specification, scanf terminates, and the character is left in the input stream as if it had not been read.

When the first format specification is encountered, the value of the first input field is converted according to this specification and stored in the location that is specified by the first argument. The second format specification causes the second input field to be converted and stored in the second argument, and so on through the end of the format string.

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

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). If a percent sign (%) is followed by a character that has no meaning as a format-control character, that character and the following characters (up to the next percent sign) are treated as an ordinary sequence of characters, that is, a sequence of characters that must match the input. For example, to specify that a percent-sign character is to be input, use %%.

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.

scanf

int  scanf ( const char * format, ... );

Parameters

format

C string that contains one or more of the following items:

• Whitespace character: the function will read and ignore any whitespace characters (this includes blank spaces and the newline and tab characters) which are encountered before the next non-whitespace character. This includes any quantity of whitespace characters, or none.
• Non-whitespace character, except percentage signs (%): Any character that is not either a whitespace character (blank, newline or tab) or part of a format specifier (which begin with a% character) causes the function to read the next character from stdin, compare it to this non-whitespace character and if it matches, it is discarded and the function continues with the next character offormat. If the character does not match, the function fails, returning and leaving subsequent characters ofstdin unread.
• Format specifiers: A sequence formed by an initial percentage sign (%) indicates a format specifier, which is used to specify the type and format of the data to be retrieved fromstdin and stored in the locations pointed by the additional arguments. A format specifier follows this prototype:
  
  %[*][width][modifiers]type
  
  where:
  
  

  *	An optional starting asterisk indicates that the data is to be retrieved fromstdin but ignored, i.e. it is not stored in the corresponding argument.
  width	Specifies the maximum number of characters to be read in the current reading operation
  modifiers	Specifies a size different from int (in the case of d, i and n), unsigned int (in the case of o, u andx) or float (in the case of e, f and g) for the data pointed by the corresponding additional argument: h : short int (for d, i and n), orunsigned short int (for o, u and x) l : long int (for d, i and n), orunsigned long int (for o, u and x), or double (fore, f and g) L : long double (for e, f and g)
  type	A character specifying the type of data to be read and how it is expected to be read. See next table.

  
  scanf type specifiers:

  type	Qualifying Input	Type of argument
  c	Single character: Reads the next character. If a width different from 1 is specified, the function readswidth characters and stores them in the successive locations of the array passed as argument. No null character is appended at the end.	char *
  d	Decimal integer: Number optionally preceded with a + or- sign.	int *
  e,E,f,g,G	Floating point: Decimal number containing a decimal point, optionally preceded by a+ or - sign and optionally folowed by the e or E character and a decimal number. Two examples of valid entries are -732.103 and 7.12e4	float *
  o	Octal integer.	int *
  s	String of characters. This will read subsequent characters until a whitespace is found (whitespace characters are considered to be blank, newline and tab).	char *
  u	Unsigned decimal integer.	unsigned int *
  x,X	Hexadecimal integer.	int *

additional arguments

The function expects a sequence of references as additional arguments, each one pointing to an object of the type specified by their corresponding%-tag within the format string, in the same order.
For each format specifier in the format string that retrieves data, an additional argument should be specified.
These arguments are expected to be references (pointers): if you want to store the result of afscanf operation on a regular variable you should precede its identifier with thereference operator, i.e. an ampersand sign (&), like in:

int n;
scanf ("%d",&n);

Return Value

Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

/* scanf example */
#include <stdio.h>int main ()
{char str [80];int i;printf ("Enter your family name: ");scanf ("%s",str);  printf ("Enter your age: ");scanf ("%d",&i);printf ("Mr. %s , %d years old.\n",str,i);printf ("Enter a hexadecimal number: ");scanf ("%x",&i);printf ("You have entered %#x (%d).\n",i,i);return 0;
}

scanf函数，与printf函数一样，都被定义在stdio.h里，因此在使用scanf函数时要加上#include<stdio.h>。它是格式输入函数，即按用户指定的格式从键盘上把数据输入到指定的变量之中，其关键字最末一个字母f即为“格式”(format)之意。
[编辑本段]scanf函数的一般形式
　　scanf(格式控制，地址表列)
　　int scanf(char *format[,argument,...]);
　　“格式控制”的含义同printf函数；“地址表列”是由若干个地址组成的表列，可以是变量的地址，或字符串首地址。
　　scanf()函数返回成功赋值的数据项数，出错时则返回EOF。
　　例：使用scanf函数输入数据。
　　#include<stdio.h>
　　void main()
　　{
　　int a,b,c;
　　printf("input a,b,c/n");
　　scanf("%d%d%d",&a,&b,&c);
　　printf("a=%d,b=%d,c=%d",a,b,c);
　　}
格式字符说明
　　%a,%A 读入一个浮点值(仅C99有效)
　　%c 读入一个字符
　　%d 读入十进制整数
　　%i 读入十进制，八进制，十六进制整数
　　%o 读入八进制整数
　　%x,%X 读入十六进制整数
　　%c 读入一个字符
　　%s 读入一个字符串，遇空格、制表符或换行符结束。
　　%f,%F,%e,%E,%g,%G 用来输入实数，可以用小数形式或指数形式输入。
　　%p 读入一个指针
　　%u 读入一个无符号十进制整数
　　%n 至此已读入值的等价字符数
　　%[] 扫描字符集合
　　%% 读%符号
　　
　　附加格式说明字符表修饰符说明
　　L/l 长度修饰符 输入"长"数据
　　h 长度修饰符 输入"短"数据
　　W 整型常数 指定输入数据所占宽度
　　* 表示本输入项在读入后不赋值给相应的变量
scanf的返回值
　　scanf的返回值有后面的参数决定
　　scanf("%d%d", &a, &b);
　　如果a和b都被成功读入，那么scanf的返回值就是2
　　如果只有a被成功读入，返回值为1
　　如果a和b都未被成功读入，返回值为0
　　如果遇到错误或遇到end of file，返回值为EOF。
　　且返回值为int型.
使用scanf函数时应该注意的问题
　　1、sacnf()中的变量必须使用地址。　
　　2、scanf()的格式控制串可以使用其它非空白字符，但在输入时必须输入这些字符。
　　3、在用"%c"输入时，空格和“转义字符”均作为有效字符。
　　问题一：scanf()函数不能正确接受有空格的字符串？如: I love you!
　　#include <stdio.h>
　　int main()
　　{
　　char str[80];
　　scanf("%s",str);
　　printf("%s",str);
　　return 0;
　　}
　　输入：I love you!
　　输出：scanf()函数接收输入数据时，遇以下情况结束一个数据的输入：（不是结束该scanf函数，scanf函数仅在每一个数据域均有数据，并按回车后结束）。
　　① 遇空格、“回车”、“跳格”键。
　　② 遇宽度结束。
　　③ 遇非法输入。
　　所以，上述程序并不能达到预期目的，scanf()扫描到"I"后面的空格就认为对str的赋值结束，并忽略后面的"love you!".这里要注意是"love you!"还在键盘缓冲区（关于这个问题，网上我所见的说法都是如此，但是，我经过调试发现，其实这时缓冲区字符串首尾指针已经相等了，也就是说缓冲区清空了，scanf()函数应该只是扫描stdin流，这个残存信息是在stdin中)。我们改动一下上面的程序来验证一下：
　　#include <stdio.h>
　　int main()
　　{
　　char str[80];
　　char str1[80];
　　char str2[80];
　　scanf("%s",str);/*此处输入:I love you! */
　　printf("%s",str);
　　sleep(5);/*这里等待5秒,告诉你程序运行到什么地方*/
　　scanf("%s",str1);/*这两句无需你再输入,是对键盘盘缓冲区再扫描 */
　　scanf("%s",str2);/*这两句无需你再输入,是对键盘盘缓冲区再扫描 */
　　printf("/n%s",str1);
　　printf("/n%s",str2);
　　return 0;
　　}
　　输入：I love you!
　　输出：
　　I
　　love
　　you!
　　好了，原因知道了，那么scanf()函数能不能完成这个任务？回答是：能！别忘了scanf()函数还有一个 %[] 格式控制符（如果对%[]不了解的请查看本文的上篇）,请看下面的程序：
　　#include "stdio.h"
　　int main()
　　{
　　char string[50];/*scanf("%s",string);不能接收空格符*/
　　scanf("%[^/n]",string);
　　printf("%s/n",string);
　　return 0;
　　}
　　问题二：键盘缓冲区残余信息问题
　　#include <stdio.h>
　　int main()
　　{
　　int a;
　　char c; do
　　{
　　scanf("%d",&a);
　　scanf("%c",&c);
　　printf("a=%d c=%c/n",a,c);/*printf("c=%d/n",c);*/
　　}while(c!='N');
　　}
　　scanf("%c",&c);这句不能正常接收字符,什么原因呢？我们用printf("c=%d/n",c);将C用int表示出来，启用printf("c=%d/n",c);这一句，看看scanf()函数赋给C到底是什么，结果是c=10 ,ASCII值为10是什么？换行即/n.对了，我们每击打一下"Enter"键，向键盘缓冲区发去一个“回车”(/r),一个“换行"(/n),在这里/r被scanf()函数处理掉了（姑且这么认为吧^_^），而/n被scanf()函数“错误”地赋给了c.解决办法：可以在两个scanf()函数之后加个fflush(stdin);，还有加getch() , getchar()也可以，但是要视具体scanf()语句加那个，这里就不分析了，读者自己去摸索吧。但是加fflush(stdin);不管什么情况都可行。
　　（
　　函数名: fflush
　　功 能: 清除一个流
　　用 法: int fflush(FILE *stream);
　　)
　　#include <stdio.h>
　　int main()
　　{
　　int a;
　　char c; do
　　{
　　scanf("%d",&a);
　　fflush(stdin);
　　scanf("%c",&c);
　　fflush(stdin);
　　printf("a=%d c=%c/n",a,c); }while(c!='N');
　　}
　　这里再给一个用“空格符”来处理缓冲区残余信息的示例：运行出错的程序：
　　#include <stdio.h>
　　int main()
　　{
　　int i;
　　char j;
　　for(i = 0;i < 10;i++)
　　{
　　scanf("%c",&j);/*这里%前没有空格*/
　　}
　　}
　　使用了空格控制符后：
　　#include <stdio.h>
　　int main()
　　{
　　int i;
　　char j;
　　for(i = 0;i < 10;i++)
　　{
　　scanf(" %c",&j);/*注意这里%前有个空格*/
　　}
　　}
　　可以运行看看两个程序有什么不同。
　　问题三： 如何处理scanf()函数误输入造成程序死锁或出错？
　　#include <stdio.h>
　　int main()
　　{
　　int a,b,c; /*计算a+b*/
　　scanf("%d,%d",&a,&b);
　　c=a+b;
　　printf("%d+%d=%d",a,b,c);
　　}
　　如上程序，如果正确输入a,b的值，那么没什么问题，但是，你不能保证使用者每一次都能正确输入，一旦输入了错误的类型，你的程序不是死锁，就是得到一个错误的结果,呵呵，这可能所有人都遇到过的问题吧？解决方法：scanf()函数执行成功时的返回值是成功读取的变量数,也就是说，你这个scanf()函数有几个变量，如果scanf()函数全部正常读取，它就返回几。但这里还要注意另一个问题，如果输入了非法数据，键盘缓冲区就可能还个有残余信息问题。正确的例程：
　　#include <stdio.h>
　　int main()
　　{
　　int a,b,c; /*计算a+b*/
　　while(scanf("%d,%d",&a,&b)!=2)fflush(stdin);
　　c=a+b;
　　printf("%d+%d=%d",a,b,c);
　　}
　　补充： fflush(stdin)这个方法在GCC下不可用。（在VC6.0下可以）
　　以下是 C99 对 fflush 函数的定义：
　　int fflush(FILE *stream);
　　如果stream指向输出流或者更新流（update stream），并且这个更新流
　　最近执行的操作不是输入，那么fflush函数将把任何未被写入的数据写入stream
　　指向的文件（如标准输出文件stdout）。否则，fflush函数的行为是不确定的。
　　fflush（NULL）清空所有输出流和上面提到的更新流。如果发生写错误，fflush
　　函数会给那些流打上错误标记，并且返回EOF，否则返回0。
　　由此可知，如果 stream 指向输入流（如 stdin），那么 fflush 函数的行为是不确定的。故而使用
　　fflush(stdin) 是不正确的，至少是移植性不好的。
　　可采用如下方法：
　　/* 此函数可以和scanf函数一起使用，但使用%c输入时要注意，即此函数只能用于缓冲区非空的情况 */
　　void flush()
　　{
　　char c;
　　while ((c=getchar()) != '/n'&&c!=EOF) ;
　　}
　　#include <stdio.h>
　　int main()
　　{
　　int a,b,c; /*计算a+b*/
　　while(scanf("%d,%d",&a,&b)!=2) flush();
　　c=a+b;
　　printf("%d+%d=%d",a,b,c);
　　}

#include <stdio.h>int main (void)
{char str1[128], str2[128], str3[128];printf ("\nEnter str1: ");scanf ("%[^\n]", str1);printf ("\nstr1 = %s", str1);printf ("\nEnter str2: ");scanf ("%[^\n]", str2);printf ("\nstr2 = %s", str2);printf ("\nEnter str3: ");scanf ("%[^\n]", str3);printf ("\nstr2 = %s", str3);printf ("\n");return 0;
}