sscanf和scanf,c++中sscanf函数与sprintf函数的用法
sscanf和scanf,c++中sscanf函数与sprintf函数的用法详细介绍
本文目录一览： c语言中关于sscanf函数的运用及%n的用法
1).sscanf函数的运用：
函数原型:
int sscanf( const char *, const char *, ...);
int sscanf(const char *buffer,const char *format,[argument ]...);
buffer存储的数据
format格式控制字符串
argument 选择性设定字符串
sscanf会从buffer里读进数据，依照format的格式将数据写入到argument里。
sscanf与scanf类似，都是用于输入的，只是后者以键盘(stdin)为输入源，前者以固定字符串为输入源。
第二个参数可以是一个或多个 {%[*] [width] [{h | I | I64 | L}]type | ' ' | '\t' | '\n' | 非%符号}
注：
1、 * 亦可用于格式中, (即 %*d 和 %*s) 加了星号 (*) 表示跳过此数据不读入. (也就是不把此数据读入参数中)
2、{a|b|c}表示a,b,c中选一，[d],表示可以有d也可以没有d。
3、width表示读取宽度。
4、{h | l | I64 | L}:参数的size,通常h表示单字节size，I表示2字节 size,L表示4字节size(double例外),l64表示8字节size。
5、type :这就很多了，就是%s,%d之类。
6、特别的：%*[width] [{h | l | I64 | L}]type 表示满足该条件的被过滤掉，不会向目标参数中写入值
失败返回0 ，否则返回格式化的参数个数
2)%n的用法
%n说明符输出有效字符数量，%n在scanf和printf中都可使用。与%n相对应的形参是一个int类型的指针，%n不影响scanf和printf的返回值。例如：
scanf("%d %d%n", &i, &j, &k);
如果输入434 6434，则k等于8，而scanf的返回值仍然为2。又如：
scanf("%c%n", &ch, &k);
输入“sbcdefdg”后，k等于1，而不是8，因为%c只取一个字符，%n输出的是有效字符数量。
%n用在printf函数里，表示输出的字符数量，例如：
printf("i=%d, j=%d\n%n", i, j, &k);
在i=343、j=123的情况下，k=12，同时%n不影响printf的返回值，其返回值仍然为12，而不是14。
%n 可以将所输出字符串的长度值赋绐一个变量, 见下例:
int slen;
printf("hello world%n", &slen);
执行后变量被赋值为11。
sscanf和scanf类似，只是从字符串输入而已
sscanf(p,"%s%n",a,&t)就是将字符串p输入到a中，长度赋值到t
代码如下：
#include
#include
int main (){
char s[200];
int n,wei;
memset(s,0,sizeof(s));
while(gets(s)){
int cnt=0,sum=0,num;
char *p=s;
while(sscanf(p,"%d%n",&n,&wei)==1){
sum+=n;cnt++;wei++;
if(p) p+=wei;
}
printf("%d %d\n",cnt,sum);
memset(s,0,sizeof(s));
}
return 0;
}
扩展资料
scanf()函数是通用终端格式化输入函数，它从标准输入设备(键盘) 读取输入的信息。可以读入任何固有类型的数据并自动把数值变换成适当的机内格式。
scanf()函数返回成功赋值的数据项数，出错时则返回EOF。
其控制串由三类字符构成：
1、格式化说明符；
2、空白符；
3、非空白符；
用空白符结尾时，scanf会跳过空白符去读下一个字符，所以必须再输入一个数。这里的空白符包括空格，制表符，换行符，回车符和换页符。所以如果用scanf("%d ",&a)也会出现同样的问题。
c语言中关于sscanf函数的运用及%n的用法
sscanf的功能和scanf差不多，只是多了一个参数，该参数放于第一个，用来标识要被解析的字符串，相对于scanf来说，他其实就是你输入的字符串。懂了不char
szText[1024]
=
"123
34.4";sscanf(szText,
"%d
%f",
&a,
&f);a
就等于123，f就是34.4f
c++中sscanf函数与sprintf函数的用法
一.sscanf 读取格式化的字符串中的数据 sscanf和scanf类似，都是用于输入的，只是后者以屏幕为输入源，而前者以固定字符串为输入。 sscanf() 是从一个字符串中读进与指定格式相符的数据 二.sprintf与printf的用法很类似，只不过是前者输出到指定的目标，后者输出到屏幕。 sprintf()指的是字符串格式化命令，主要功能是把格式化的数据写入某个字符串中。 int scanf(const char format [,agument]) 其中format可以是一个或多个 {%[ ][width][{h | l | l64 | L}]}type {a|b|c}表示a、b、c中选一，[d]表示d是可有可无的。 所以，format形式可以有： %s %5s %[a-z]5d 注意： %*[width][{h | l | l64 | L}]}type表示过滤满足条件的字符串，不向目标中输出。
1、基本用法，取字符串 string source0 = "1234456"; char str[521]; sscanf(source0.c_str(),"%s",str); sscanf(source0.c_str(),"%4s",str);
2、转换为整型数 string source0 = "123456"; int x; sscanf(source0.c_str(),"%d",&x); sscanf(source0.c_str(),"%3d",&x);
3、停止和范围 sscanf(source0,"%[^a]",str); //遇到“a”停止 sscanf(source0,"%[^c]",str); //遇到“c”停止 sscanf(source0,"%[1-9A-Z]",str); //只取范围1-9和A-Z的字符 sscanf(source0,"%[^b-z]",str); //遇到“b-z”停止 sscanf(source0,"%[^c-z]",str); //遇到“c-z”停止
4、格式转换 char source[512] = "2015:8:1"; int a,b,c; sscanf(source,"%d:%d:%d",&a,&b,&c); 注意：这个地方a、b、c必须加引用，否则会报错。
5、复杂情况 char source[512] = "fjkdsjf/123456@fjkdsjf"; char str[512]; sscanf(source,"%*[ /]/%[ @]",str); 结果为：123456
sprintf sprintf与printf的用法很类似，只不过是前者输出到指定的目标，后者输出到屏幕。 int sprintf(char *buffer,const char *format,...) 举个例子：
结果： 1 buf = 1 buf = 00000001 2 buf = 2 buf = 00000002
C语言 sscanf() 用法
尖括号一定存在的话，直接找到尖括号的起始位置就行了。
char os[100];const char* str = "
123";const char* p = strchr(str, '<') + 1;assert(p!=NULL);sscanf(p, "%[^>]", os);puts(os);
C语言函数sscanf()的用法
sscanf() - 从一个字符串中读进与指定格式相符的数据.
函数原型:
int sscanf( string str, string fmt, mixed var1, mixed var2 ... );
int scanf( const char *format [,argument]... );
说明：
sscanf与scanf类似，都是用于输入的，只是后者以屏幕(stdin)为输入源，前者以固定字符串为输入源。
其中的format可以是一个或多个 {%[*] [width] [{h | l | I64 | L}]type | ' ' | '\t' | '\n' | 非%符号}
注：
1、 * 亦可用于格式中, (即 %*d 和 %*s) 加了星号 (*) 表示跳过此数据不读入. (也就是不把此数据读入参数中)
2、{a|b|c}表示a,b,c中选一，[d],表示可以有d也可以没有d。
3、width表示读取宽度。
4、{h | l | I64 | L}:参数的size,通常h表示单字节size，I表示2字节 size,L表示4字节size(double例外),l64表示8字节size。
5、type :这就很多了，就是%s,%d之类。
6、特别的：%*[width] [{h | l | I64 | L}]type 表示满足该条件的被过滤掉，不会向目标参数中写入值
支持集合操作：
%[a-z] 表示匹配a到z中任意字符，贪婪性(尽可能多的匹配)
%[aB'] 匹配a、B、'中一员，贪婪性
%[^a] 匹配非a的任意字符，贪婪性
注意：在读入的字符串是空字符串时，sscanf函数并不改变待读入到的字符串的值。
怎么利用sscanf() 读取字符窜中的整数 VC++？
char buff[512];
sscanf("basis= 24 time is up","%[1-9]",buf); //取出整数
printf("%s\n",buf);
int a=0;
a=atoi(buff); //将数字字符串转化为整数
sscanf()函数用于从字符串中读取指定格式的数据，其原型如下：
int sscanf (char *str, char * format [, argument, ...]);
【参数】参数str为要读取数据的字符串；format为用户指定的格式；argument为变量，用来保存读取到的数据。
【返回值】成功则返回参数数目，失败则返回-1，错误原因存于errno 中。
sscanf()会将参数str 的字符串根据参数format（格式化字符串）来转换并格式化数据（格式化字符串请参考scanf()）， 转换后的结果存于对应的变量中。
sscanf()与scanf()类似，都是用于输入的，只是scanf()以键盘(stdin)为输入源，sscanf()以固定字符串为输入源。
【实例】从指定的字符串中读取整数和小写字母。#include
int main(void){ char str[100] ="123568qwerSDDAE"; char lowercase[100]; int num; sscanf(str,"%d %[a-z]", &num, lowercase); printf("The number is: %d.\n", num); printf("The lowercase is: %s.", lowercase); return 0;}
输出结果：
The number is: 123568.
The lowercase is: qwer.
可以看到format参数有些类似正则表达式（当然没有正则表达式强大，复杂字符串建议使用正则表达式处理），支持集合操作，例如：
%[a-z] 表示匹配a到z中任意字符，贪婪性(尽可能多的匹配)
%[aB'] 匹配a、B、'中一员，贪婪性
%[^a] 匹配非a的任意字符，贪婪性
另外，format不仅可以用空格界定字符串，还可以用其他字符界定，可以实现简单的字符串分割（更加灵活的字符串分割请使用strtok()）。例如：
sscanf("2006:03:18", "%d:%d:%d", a, b, c);
sscanf("2006:03:18 - 2006:04:18", "%s - %s", sztime1, sztime2);
fscanf,sscanf,fprintf,sprintf之间的区别是什么，各有什么具体的应用？
f开头代表 file
s开头代表 string
可以这么理解.
什么都不带的, 在标准 键盘 屏幕(控制台) 出入输出.
fscanf,sscanf,fprintf,sprintf还有scanf,printf
共同点是都是格式化输入/输出用的，它们的格式化方法/通配符都是一样的。
不同之处：
f打头的是文件I/O
s打头的是字符串I/O
俩字头都不带的是屏幕con的I/O
scanf(%[^n],c)具体含义
%[^\n] 哈哈 这个不是刚才我回答那个问题么 ^ 这个符号的意思 是取反
然后%[^\n] 表示除了 换行符号 都可以 存入 字符串 c中
因为是数组 &的 可用 可 不用 你的理解是对的
不是说 %s不可以用
用 scanf("%s",c) 也是对的
http://hi.baidu.com/rjz78/blog/item/fb8df4943ffbe316d21b7090.html
可以看一下这篇文章，讲得很详细。
对于数组，加不加&是无所谓的，用%s格式时也是一样。
建议你百度看下 正则表达式
%[^n]表示接收非n字符的字符串。
c是一段连续空间的名字，跟指针完全不一样。不过在值传递时传的是首元素地址，所以scanf("",s)这里s是首元素地址，scanf("",&s)取这段空间的首地址，同样是首元素地址。
scanf和sscanf函数对数据过滤有很多操作，可以百度下。以下sscanf的用法同样适用scanf
sscanf() - 从一个字符串中读进与指定格式相符的数据.
函数原型:
Int sscanf( string str, string fmt, mixed var1, mixed var2 ... );
int scanf( const char *format [,argument]... );
说明：
sscanf与scanf类似，都是用于输入的，只是后者以屏幕(stdin)为输入源，前者以固定字符串为输入源。
其中的format可以是一个或多个 {%[*] [width] [{h | l | I64 | L}]type | ' ' | '\t' | '\n' | 非%符号}
注：
1、 * 亦可用于格式中, (即 %*d 和 %*s) 加了星号 (*) 表示跳过此数据不读入. (也就是不把此数据读入参数中)
2、{a|b|c}表示a,b,c中选一，[d],表示可以有d也可以没有d。
3、width表示读取宽度。
4、{h | l | I64 | L}:参数的size,通常h表示单字节size，I表示2字节 size,L表示4字节size(double例外),l64表示8字节size。
5、type :这就很多了，就是%s,%d之类。
6、特别的：%*[width] [{h | l | I64 | L}]type 表示满足该条件的被过滤掉，不会向目标参数中写入值
支持集合操作：
%[a-z] 表示匹配a到z中任意字符，贪婪性(尽可能多的匹配)
%[aB'] 匹配a、B、'中一员，贪婪性
%[^a] 匹配非a的任意字符，贪婪性
例子：
1. 常见用法。
char buf[512] = ;
sscanf("123456 ", "%s", buf);
printf("%s\n", buf);
结果为：123456
2. 取指定长度的字符串。如在下例中，取最大长度为4字节的字符串。
sscanf("123456 ", "%4s", buf);
printf("%s\n", buf);
结果为：1234
3. 取到指定字符为止的字符串。如在下例中，取遇到空格为止字符串。
sscanf("123456 abcdedf", "%[^ ]", buf);
printf("%s\n", buf);
结果为：123456
4. 取仅包含指定字符集的字符串。如在下例中，取仅包含1到9和小写字母的字符串。
sscanf("123456abcdedfBCDEF", "%[1-9a-z]", buf);
printf("%s\n", buf);
结果为：123456abcdedf
5. 取到指定字符集为止的字符串。如在下例中，取遇到大写字母为止的字符串。
sscanf("123456abcdedfBCDEF", "%[^A-Z]", buf);
printf("%s\n", buf);
结果为：123456abcdedf
6、给定一个字符串iios/12DDWDFF@122，获取 / 和 @ 之间的字符串，先将 "iios/"过滤掉，再将非'@'的一串内容送到buf中
sscanf("iios/12DDWDFF@122", "%*[^/]/%[^@]", buf);
printf("%s\n", buf);
结果为：12DDWDFF
7、给定一个字符串““hello, world”，仅保留world。（注意：“，”之后有一空格）
sscanf(“hello, world”, "%*s%s", buf);
printf("%s\n", buf);
结果为：world
%*s表示第一个匹配到的%s被过滤掉，即hello被过滤了
如果没有空格则结果为NULL。
sscanf的功能很类似于正则表达式, 但却没有正则表达式强大,所以如果对于比较复杂的字符串处理,建议使用正则表达式.
//-------------------------------------------------------
sscanf,表示从字符串中格式化输入
上面表示从str中，输入数字给x，就是32700
久以前，我以为c没有自己的split string函数，后来我发现了sscanf；一直以来，我以为sscanf只能以空格来界定字符串，现在我发现我错了。
sscanf是一个运行时函数，原形很简单：
int sscanf(
const char *buffer,
const char *format [,
argument ] ...
);
它强大的功能体现在对format的支持上。
我以前用它来分隔类似这样的字符串2006:03:18:
int a, b, c;
sscanf("2006:03:18", "%d:%d:%d", a, b, c);
以及2006:03:18 - 2006:04:18:
char sztime1[16] = "", sztime2[16] = "";
sscanf("2006:03:18 - 2006:04:18", "%s - %s", sztime1, sztime2);
但是后来，我需要处理2006:03:18-2006:04:18
仅仅是取消了‘-’两边的空格，却打破了%s对字符串的界定。
我需要重新设计一个函数来处理这样的情况？这并不复杂，但是，为了使所有的代码都有统一的风格，我需要改动很多地方，把已有的sscanf替换成我自己的分割函数。我以为我肯定需要这样做，并伴随着对sscanf的强烈不满而入睡；一觉醒来，发现其实不必。
format-type中有%[]这样的type field。如果读取的字符串，不是以空格来分隔的话，就可以使用%[]。
%[]类似于一个正则表达式。[a-z]表示读取a-z的所有字符，[^a-z]表示读取除a-z以外的所有字符。
所以那个问题也就迎刃而解了:
sscanf("2006:03:18 - 2006:04:18", "%[0-9,:] - %[0-9,:]", sztime1, sztime2);
在softmse (Jake) 的问题贴http://community.csdn.net/Expert/topic/4843/4843294.xml?temp=.4321558中 ，周星星给出了一个很cool的sscanf用例，而后通过学习，发现sscanf真棒，现做一总结。
原问题：
iios/12DDWDFF@122
获取/和@之间的字符串怎么做
C程序里面有什么函数吗?
周星星的代码：
#include
int main()
{
const char* s = "iios/12DDWDFF@122";
char buf[20];
sscanf( s, "%*[^/]/%[^@]", buf );
printf( "%s\n", buf );
return 0;
}
结果为:12DDWDFF
sscanf与scanf类似，都是用于输入的，只是后者以屏幕(stdin)为输入源，前者以固定字符串为输入源。
函数原型：
int scanf( const char *format [,argument]... );
其中的format可以是一个或多个 {%[*] [width] [{h | l | I64 | L}]type | ' ' | '\t' | '\n' | 非%符号}，
注：{a|b|c}表示a,b,c中选一，[d],表示可以有d也可以没有d。
width:宽度，一般可以忽略，用法如：
const char sourceStr[] = "hello, world";
char buf[10] = ;
sscanf(sourceStr, "%5s", buf); //%5s，只取5个字符
cout << buf<< endl;
结果为:hello
{h | l | I64 | L}:参数的size,通常h表示单字节size，I表示2字节 size,L表示4字节size(double例外),l64表示8字节size。
type :这就很多了，就是%s,%d之类。
特别的：
%*[width] [{h | l | I64 | L}]type 表示满足该条件的被过滤掉，不会向目标参数中写入值。如：
const char sourceStr[] = "hello, world";
char buf[10] = ;
sscanf(sourceStr, "%*s%s", buf); //%*s表示第一个匹配到的%s被过滤掉，即hello被过滤了
cout << buf<< endl;
结果为:world
支持集合操作：
%[a-z] 表示匹配a到z中任意字符，贪婪性(尽可能多的匹配)
%[aB'] 匹配a、B、'中一员，贪婪性
%[^a] 匹配非a的任意字符，贪婪性
是不是感觉眼熟了啊，不错，这和正则表达式很相似，而且仍然支持过滤，即可以有%*[a-z].如：
星星大哥例子回顾：
const char* s = "iios/12DDWDFF@122";
char buf[20];
sscanf( s, "%*[^/]/%[^@]", buf );
printf( "%s\n", buf );
由例子3－》取到指定字符为止的字符串。如在下例中，取遇到空格为止字符串。
sscanf("123456 abcdedf", "%[^ ]", buf);
printf("%s\n", buf);
结果为：123456
所以周星星的代码总结应该为：
const char* s = "iios/12DDWDFF@122";
char buf[20];
sscanf( s, "%*[^/]/%[^@]", buf );
printf( "%s\n", buf );
先将 "iios/"过滤掉，再将到字符'@'为止的一串12DDWDFF（由例3可得此串到@为止，把@122舍掉）内容即是：12DDWDFF送到buf中，得到结果。
C语言怎么根据ASCII码判断输入的数据是字符串还是纯数字
0到9的的ascii码全是从0x30到0x39的,你只需要判断一个字符是不是在这个范围就知道是不是数字了
C语言使用的读入键盘输入的函数较常用的一般有：
scanf
fscanf
sscanf
getchar
gets
scanf、fscanf、sscanf
根据你定义的字符格式来判断是字符串还是纯数字。
例如：
scanf("%d",&a);
使用了格式控制%d就表示输入的十进制整数；
scanf("%",a);控制%s就表示输入的字符串。
详细格式控制符如下：
a
读浮点值(仅适用于
C99)
A
读浮点值(仅适用于
C99)
c
读单字符
d
读十进制整数
i
读十进制、八进制、十六进制整数
e
读浮点数
E
读浮点数
f
读浮点数
F
读浮点数(仅适用于
C99)
g
读浮点数
G
读浮点数
o
读八进制数
s
读字符串
x
读十六进制数
X
读十六进制数
p
读指针值
n
至此已读入值的等价字符数
u
读无符号十进制整数
[
]
扫描字符集合
%
读
%
符号(百分号)
gets一般直接默认输入的就是字符串，即使你输入一串数字，也会认为你输入的是字符数字；
getchar一般直接默认输入字符。
sscanf()如何实现？
//来源：http://bbs.csdn.net/topics/380134728/****sscanf.c - read formatted data from string** Copyright (c) Microsoft Corporation. All rights reserved.**Purpose:* defines scanf() - reads formatted data from string********************************************************************************/#include
#include
#include
#include
#include
#include
#include
#include
/****static int vscan_fn([w]inputfn, string, [count], format, ...)**Purpose:* this is a helper function which is called by the other functions* in this file - sscanf/swscanf/snscanf etc. It calls either _(w)input or* _(w)input_s depending on the first parameter.********************************************************************************/static int __cdecl vscan_fn ( TINPUTFN inputfn, REG2 const _TCHAR *string,#ifdef _SNSCANF size_t count,#endif /* _SNSCANF */ const _TCHAR *format, _locale_t plocinfo, va_list arglist )/* * 'S'tring 'SCAN', 'F'ormatted */{ FILE str = { 0 }; REG1 FILE *infile = &str; REG2 int retval;#ifndef _SNSCANF size_t count;#endif /* _SNSCANF */ _VALIDATE_RETURN( (string != NULL), EINVAL, EOF); _VALIDATE_RETURN( (format != NULL), EINVAL, EOF);#ifndef _SNSCANF count=_tcslen(string);#endif /* _SNSCANF */ infile->_flag = _IOREAD|_IOSTRG|_IOMYBUF; infile->_ptr = infile->_base = (char *) string; if(count>(INT_MAX/sizeof(_TCHAR))) { /* old-style functions allow any large value to mean unbounded */ infile->_cnt = INT_MAX; } else { infile->_cnt = (int)count*sizeof(_TCHAR); } retval = (inputfn(infile, format, plocinfo, arglist)); return(retval);}/****int sscanf(string, format, ...) - read formatted data from string**Purpose:* Reads formatted data from string into arguments. _input does the real* work here. Sets up a FILE so file i/o operations can be used, makes* string look like a huge buffer to it, but _filbuf will refuse to refill* it if it is exhausted.** Allocate the 'fake' _iob[] entryit statically instead of on* the stack so that other routines can assume that _iob[] entries are in* are in DGROUP and, thus, are near.** Multi-thread: (1) Since there is no stream, this routine must never try* to get the stream lock (i.e., there is no stream lock either). (2)* Also, since there is only one staticly allocated 'fake' iob, we must* lock/unlock to prevent collisions.**Entry:* char *string - string to read data from* char *format - format string* followed by list of pointers to storage for the data read. The number* and type are controlled by the format string.**Exit:* returns number of fields read and assigned**Exceptions:********************************************************************************//****int snscanf(string, size, format, ...) - read formatted data from string of* given length**Purpose:* Reads formatted data from string into arguments. _input does the real* work here. Sets up a FILE so file i/o operations can be used, makes* string look like a huge buffer to it, but _filbuf will refuse to refill* it if it is exhausted.** Allocate the 'fake' _iob[] entryit statically instead of on* the stack so that other routines can assume that _iob[] entries are in* are in DGROUP and, thus, are near.** Multi-thread: (1) Since there is no stream, this routine must never try* to get the stream lock (i.e., there is no stream lock either). (2)* Also, since there is only one staticly allocated 'fake' iob, we must* lock/unlock to prevent collisions.**Entry:* char *string - string to read data from* size_t count - length of string* char *format - format string* followed by list of pointers to storage for the data read. The number* and type are controlled by the format string.**Exit:* returns number of fields read and assigned**Exceptions:********************************************************************************/#ifdef _UNICODE#ifdef _SNSCANFint __cdecl _snwscanf (#else /* _SNSCANF */int __cdecl swscanf (#endif /* _SNSCANF */#else /* _UNICODE */#ifdef _SNSCANFint __cdecl _snscanf (#else /* _SNSCANF */int __cdecl sscanf (#endif /* _SNSCANF */#endif /* _UNICODE */ REG2 const _TCHAR *string,#ifdef _SNSCANF size_t count,#endif /* _SNSCANF */ const _TCHAR *format, ... ){ va_list arglist; va_start(arglist, format);#ifdef _SNSCANF return vscan_fn(_tinput_l, string, count, format, NULL, arglist);#else /* _SNSCANF */ return vscan_fn(_tinput_l, string, format, NULL, arglist);#endif /* _SNSCANF */}#ifdef _UNICODE#ifdef _SNSCANFint __cdecl _snwscanf_l (#else /* _SNSCANF */int __cdecl _swscanf_l (#endif /* _SNSCANF */#else /* _UNICODE */#ifdef _SNSCANFint __cdecl _snscanf_l (#else /* _SNSCANF */int __cdecl _sscanf_l (#endif /* _SNSCANF */#endif /* _UNICODE */ REG2 const _TCHAR *string,#ifdef _SNSCANF size_t count,#endif /* _SNSCANF */ const _TCHAR *format, _locale_t plocinfo, ... ){ va_list arglist; va_start(arglist, plocinfo);#ifdef _SNSCANF return vscan_fn(_tinput_l, string, count, format, plocinfo, arglist);#else /* _SNSCANF */ return vscan_fn(_tinput_l, string, format, plocinfo, arglist);#endif /* _SNSCANF */}/****int sscanf_s(string, format, ...)* Same as sscanf above except that it calls _input_s to do the real work.**int snscanf_s(string, size, format, ...)* Same as snscanf above except that it calls _input_s to do the real work.** _input_s has a size check for array parameters.********************************************************************************/#ifdef _UNICODE#ifdef _SNSCANFint __cdecl _snwscanf_s (#else /* _SNSCANF */int __cdecl swscanf_s (#endif /* _SNSCANF */#else /* _UNICODE */#ifdef _SNSCANFint __cdecl _snscanf_s (#else /* _SNSCANF */int __cdecl sscanf_s (#endif /* _SNSCANF */#endif /* _UNICODE */ REG2 const _TCHAR *string,#ifdef _SNSCANF size_t count,#endif /* _SNSCANF */ const _TCHAR *format, ... ){ va_list arglist; va_start(arglist, format);#ifdef _SNSCANF return vscan_fn(_tinput_s_l, string, count, format, NULL, arglist);#else /* _SNSCANF */ return vscan_fn(_tinput_s_l, string, format, NULL, arglist);#endif /* _SNSCANF */}#ifdef _UNICODE#ifdef _SNSCANFint __cdecl _snwscanf_s_l (#else /* _SNSCANF */int __cdecl _swscanf_s_l (#endif /* _SNSCANF */#else /* _UNICODE */#ifdef _SNSCANFint __cdecl _snscanf_s_l (#else /* _SNSCANF */int __cdecl _sscanf_s_l (#endif /* _SNSCANF */#endif /* _UNICODE */ REG2 const _TCHAR *string,#ifdef _SNSCANF size_t count,#endif /* _SNSCANF */ const _TCHAR *format, _locale_t plocinfo, ... ){ va_list arglist; va_start(arglist, plocinfo);#ifdef _SNSCANF return vscan_fn(_tinput_s_l, string, count, format, plocinfo, arglist);#else /* _SNSCANF */ return vscan_fn(_tinput_s_l, string, format, plocinfo, arglist);#endif /* _SNSCANF */}
sscanf与scanf类似，都是用于输入的，只是后者以键盘(stdin)为输入源，前者以固定字符串为输入源。
举个例子给你看：
char* pQueryStr=getenv("QUERY_STRING");
char pName[256];
sscanf(pQueryStr,"name=%s",pName);
printf("Hello %s!\n",pName);
最后显示出来的就是：Hello tom!
c语言中scanf括号里&什么意思
代表取地址的意思，如scanf（“%d”，&a），则代表输入的数据将被填充到地址为&a的内存空间上，而&a的地址就是存储a的，所以输入的数据就存储到变量a中。
用scanf("%d,%d",&a,&b);的时候。你输入的时候输入两个数，中间还要用逗号隔开的，否则会出错。用scanf("%d%d",&a,&b);的时候，你输入两个数的时候，不用输入逗号。可以用空格隔开。
在c语言中，scanf("%d%*c", &n);中%d表示读整数，%*c表示忽略掉一个字符型的输入项，&n表示对象n在内存中的地址。scanf("%d%*c", &n);整体表示输入两个数，并且忽略掉第二个字符型的输入项，然后将输入的对象存入n。
在C语言的scanf函数中，格式字符串的一般形式为：%[*][输入数据宽度][长度]类型（其中有方括号[]的项为任选项）。不同的格式符类型有不同的功能。
扩展资料
C语言scanf函数的语法规则：
1、语法
#include
int scanf( const char *format, ... );
类似函数有
int scanf(const char *format, ...);
int fscanf(FILE *stream, const char *format, ...);//定输入流
int sscanf(const char *str, const char *format, ...);//指定缓存区
2、规则
scanf()函数根据由format(格式)指定的格式从stdin(标准输入)读取,并保存数据到其它参数. 它和printf()有点类似. format(格式)字符串由控制字符,空白字符和非空白字符组成. 控制字符以一个%符号开始。
参考资料来源：百度百科——scanf