C语言中main函数参数用法

一.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()的用法 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 | " " | " " | " " | 非%符号} 　　注： 　　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,表示从字符串中格式化输入上面表示从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 <stdio.h>int main(){ const char* s = "iios/12DDWDFF@122"; char buf[20]; sscanf( s, "%*[^/]/%[^@]", buf ); printf( "%s ", buf ); return 0;}结果为:12DDWDFFsscanf与scanf类似，都是用于输入的，只是后者以屏幕(stdin)为输入源，前者以固定字符串为输入源。函数原型：int scanf( const char *format [,argument]... );其中的format可以是一个或多个 {%[*] [width] [{h | l | I64 | L}]type | " " | " " | " " | 非%符号}，注：{a|b|c}表示a,b,c中选一，[d],表示可以有d也可以没有d。width:宽度，一般可以忽略，用法如：const char sourceStr[] = "hello, world";char buf[10] = {0};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] = {0};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 ", buf );先将 "iios/"过滤掉，再将非"@"的一串内容送到buf中，cool.得到结果。PS: 向星星大哥和softmse (Jake) 致谢了，有了你们才有它啊

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 | " " | " " | " " | 非%符号}注：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", i, j, &k);在i=343、j=123的情况下，k=12，同时%n不影响printf的返回值，其返回值仍然为12，而不是14。

sscanf()函数用于从字符串中读取指定格式的数据，其原型如下： int sscanf (char *str, char * format [, argument, ...]);【参数】参数str为要读取数据的字符串；format为用户指定的格式；argument为变量，用来保存读取到的数据。【返回值】成功则返回参数数目，失败则返回-1，错误原因存于errno 中。sscanf()会将参数str 的字符串根据参数format（格式化字符串）来转换并格式化数据（格式化字符串请参考scanf()）， 转换后的结果存于对应的变量中。sscanf()与scanf()类似，都是用于输入的，只是scanf()以键盘(stdin)为输入源，sscanf()以固定字符串为输入源。【实例】从指定的字符串中读取整数和小写字母。#include <stdio.h>int main(void){ char str[100] ="123568qwerSDDAE"; char lowercase[100]; int num; sscanf(str,"%d %[a-z]", &num, lowercase); printf("The number is: %d. ", 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);

C语言中有该输入语句及格式化输入1. 常见用法。 char buf[512] ; sscanf("123456 ", "%s", buf);//此处buf是数组名，它的意思是将123456以%s的形式存入buf中！ printf("%s ", buf); 结果为：123456 2. 取指定长度的字符串。如在下例中，取最大长度为4字节的字符串。 sscanf("123456 ", "%4s", buf); printf("%s ", buf); 结果为：1234 3. 取到指定字符为止的字符串。如在下例中，取遇到空格为止字符串。 sscanf("123456 abcdedf", "%[^ ]", buf); printf("%s ", buf); 结果为：123456 4. 取仅包含指定字符集的字符串。如在下例中，取仅包含1到9和小写字母的字符串。 sscanf("123456abcdedfBCDEF", "%[1-9a-z]", buf); printf("%s ", buf); 结果为：123456abcdedf 当输入： sscanf("123456abcdedfBCDEF","%[1-9A-Z]",buf); printf("%s ",buf); 结果为：123456

sscanf(str,"%[^ ]%[ ]%s",s[0],s[1],s[2]); //关键在这里用的格式。第一个格式是以空格为读的结束第二个格式是只读空格，遇别的字符 读 结束第三个格式平时常用，就不多说了。下面是完整程序，说明怎样读得空格。假定已知字符串 "abcd 123"; 显然有3个空格。我们要把前后2段字符串读入 s[0],s[2], 中段空格读入s[1].输出 读到的3个字符串的 长度 和 字符串内容 （用 | 分开，以便你看得清楚）#include <stdio.h>main(){char str[]="abcd 123";char s[3][10];sscanf(str,"%[^ ]%[ ]%s",s[0],s[1],s[2]); //关键在这里用的格式。printf("%d %d %d ",strlen(s[0]),strlen(s[1]),strlen(s[2]));printf("%s|%s|%s ",s[0],s[1],s[2]);return 0;}输出为： 4 3 3abcd| |123

如果能，怎么提取。。给个例子 由于我编的是 用c语言写的 汇编语言编译程序 init: STOREB Z cell提取冒号后面的字符串，最好跳过空格。。

头文件 #include 定义函数 int sscanf (const char *str,const char * format,........); 函数说明 sscanf()会将参数str的字符串根据参数format字符串来转换并格式化数据。格式转换形式请参考scanf()。转换后的结果存于对应的参数内。 返回值 成功则返回参数数目，失败则返回-1，错误原因存于errno中。 返回0表示失败 否则，表示正确格式化数据的个数 例如：sscanf(str，"%d%d%s", &i,&i2, &s); 如果三个变成都读入成功会返回3。 如果只读入了第一个整数到i则会返回1。证明无法从str读入第二个整数。 范例 #include main() { int i; unsigned int j; char input[ ]=”10 0x1b aaaaaaaa bbbbbbbb”; char s[5]; sscanf(input,”%d %x %5[a-z] %*s %f”,&i,&j,s,s); printf(“%d %d %s ”,i,j,s); } 执行 10 27 aaaaa sscanf(stringBuf.c_str(), "%20[^#]#%20[^ ]",......)语句中""中的内容含义为： “%[ ]”符号用于声明字符串，它比“%s”更具体，可以用于设置读取的样式。例如“%[a-z]”只读取小写字母，读到其它字符就结束。注意，方括号中如果有“^”，代表一直读到某字符为止。例如： “%[^#]”：读取字符串，一直到出现“＃”号为止。 “%20[^#]”：读取20个字节的字符串，出现“＃”号时结束。 所以，“%20[^#]#%20[^ ]”的意义就是， 读取两个20字节大小的字符串，第一个字符串可以用＃结束，第二个字符串可以用回车符结束。

sscanf的功能和scanf差不多，只是多了一个参数，该参数放于第一个，用来标识要被解析的字符串，相对于scanf来说，他其实就是你输入的字符串。懂了不charszText[1024]="12334.4";sscanf(szText,"%d%f",&a,&f);a就等于123，f就是34.4f

行。但有好多细节要掌握好，比如sscanf(buffer, "%d %s", &index, name);中buffer里的串必须是第一个是整型数串，而后是空格(可以不至1个)，再后是一个字符串。如果不是这样，读取就要出错。区分英文汉语也是可以的；不过没有区分开的必要啊，直接一个字符串“hello，你好”这样也是可行的。

int data; //保存第二个下划线后面的数字FILE *fp=fopen("c:\file.txt","r");fscanf(fp,"%*[10]c%d%*[10]c",&data);//如果一个空格都没有的话，可以循环，用这个函数读出所有的数据 ,"%*[10]c表示跳出前10个数据，%d表示读出整形数据， 表示跳过行尾

字符串输入格式 ，逗号分隔 用 "%[^,], 格式。逗号空白分隔 用 "%[^," "]%*c:sscanf(str,"%[^," "]%*c%lf,%lf,%lf",name,&iC1,&iC2,&iC3);空白分隔 用 %s %lf %lf %lf 格式#include <iostream>using namespace std;#include <stdio.h>#include <stdlib.h>int main(){char str[]="wang,3,4,5"; char name[10];double iC1,iC2,iC3;sscanf(str,"%[^,],%lf,%lf,%lf",name,&iC1,&iC2,&iC3);printf("%s %lf %lf %lf ",name,iC1,iC2,iC3);return 0;}输出double型,可以用%lf 格式。

sscanf与scanf类似，都是用于输入的，只是后者以键盘(stdin)为输入源，前者以固定字符串为输入源。举个例子给你看：char* pQueryStr=getenv("QUERY_STRING");char pName[256]; sscanf(pQueryStr,"name=%s",pName); printf("Hello %s! ",pName);最后显示出来的就是：Hello tom!

%[^&]的意思是指输入的数据要遇上&才结束；比如说在处理字符串中的scanf("%s",a);如果普通的话遇上了空格或者回车就结束了；但把它改成这个样子scanf("%[^=]",a);就表示在输入数据中是以‘="为结束标志的。在遇到空格和回车都不结束当前输入。这句话有意思的地方就在于当使用这种特殊结束标志以后，这个标志不但不会被存储在对应的存储空间里，而且输出的时候按照普通方法即可输出所输入的字符；比如我说，我输入了：sdfasf asdfasf adf asfadsffds =使用printf("%s",a)；它就会按照原样式输出到"=‘前的位置；

2楼、3楼 皆为正解。初始化你的 buf2 和 buf3，然后再执行你原来的语句，就能看出 buf2 和 buf3 里什么都没读入。未读入的原因是 patten1 读取了 Beijing，而从 "g" 到 "," 之间并没有任何字符。乱码是因为你没有初始化。所以解决方法就是：1） 跳过一个字符（2楼）2） 跳过一个逗号（3楼）以上任何一种方法都可以

%[0-9]的意思是输入0～9之间的字符，在遇到不是这个范围的数据时停止，你的str上来就是一组不属于这个范围的字符，所以temp采集失败。这一点你可以观察sscanf的返回值得知。

跳过5个读3个：#include <stdio.h> main(){ char s1[120]="ATOM 1 SPH ION 1 -12.000 -6.000 -2.000 -0.07 1.70 ";float a1[3]; int i;sscanf(s1,"%*s %*s %*s %*s %*s %f %f %f",&a1[0],&a1[1],&a1[2]);for (i=0;i<3;i++) printf("%f ",a1[i]);printf(" ");return 0; } ---空格，tab 都是“空白”，只要它们用 空白分 隔 就可以用这种方法。一个 %*s 就是跳一个字符串，一个 %f 就是读1个 float.如果 用 %lf 就是读 double ( 无论 是 定点还是 e 格式）

sscanf(str,"%[^ ]%[ ]%s",s[0],s[1],s[2]); //关键在这里用的格式。第一个格式是以空格为读的结束第二个格式是只读空格，遇别的字符 读 结束第三个格式平时常用，就不多说了。下面是完整程序，说明怎样读得空格。假定已知字符串 "abcd 123"; 显然有3个空格。我们要把前后2段字符串读入 s[0],s[2], 中段空格读入s[1].输出 读到的3个字符串的 长度 和 字符串内容 （用 | 分开，以便你看得清楚）#include <stdio.h>main(){char str[]="abcd 123";char s[3][10];sscanf(str,"%[^ ]%[ ]%s",s[0],s[1],s[2]); //关键在这里用的格式。printf("%d %d %d ",strlen(s[0]),strlen(s[1]),strlen(s[2]));printf("%s|%s|%s ",s[0],s[1],s[2]);return 0;}输出为： 4 3 3abcd| |123

charstr[]="lloyd2";intl=strlen(str);//这里是获得这个字符串的长度，长度为6//通过长度，我们可以获取到他的最后一个字符//由于数组下标是从0开始的，所以数组下标的最大值始终要比长度小1//那这个字符串的最后一个字符就是charc=str[l-1];

scanf遇到回车空格，TAB跳过（当然如果是接收字符例外）sscanf也是

　　主要有两个方法，其实都是对现有函数的使用：　　　　方法1: sscanf()　　　　函数名: sscanf　　功 能: 从字符串格式化输入　　用 法: int sscanf(char *string, char *format[,argument,...]);　　　　以上的 format 为 %x 就是将字符串格式化为 16 进制数　　　　例子：　　　　#include <stdio.h>　　void main()　　{　　char* p = "0x1a";　　int nValude = 0;　　sscanf(p, "%x", &nValude);　　printf("%d ", nValude);　　}　　输出：　　26　　　　方法2: strtol()　　　　函数名: strtol　　功 能: 将字符串转换为长整数　　用 法: long strtol(char *str, char **endptr, int base);　　　　上面的base就是我们要转换为几进制数　　例子：　　　　#include <stdio.h>　　#include <stdlib.h>　　void main()　　{　　char* p = "0x1b";　　char* str;　　long i = strtol(p, &str, 16);　　printf("%d ", i);　　}　　　　输出：　　27　　　　其实还有一种方法，就是用一个初始化为0~9~a~f的字符串数组，也就是一个十六进制对应表，用这个对应表即可算出一个十六进制字符串的数值，但这种发发太麻烦了，不推荐使用。

这个结果应该是获取/到@之间的字符吧第一个^/表示非/的字符 而*是忽略符 就是忽略在/之前的非/字符对吧 但是到了/以后 这个斜杠自身还没有被忽略掉 所以还要再忽略掉/自身 于是便将/加在了后面这个语句其实分成%*[^/]/和%[^@]两个部分 这样应该明白了吧？或者说括号外的/就是代表字符串中的/ 用来顶替它的位置的。

这个结果应该是获取/到@之间的字符吧第一个^/表示非/的字符而*是忽略符就是忽略在/之前的非/字符对吧但是到了/以后这个斜杠自身还没有被忽略掉所以还要再忽略掉/自身于是便将/加在了后面这个语句其实分成%*[^/]/和%[^@]两个部分这样应该明白了吧？或者说括号外的/就是代表字符串中的/用来顶替它的位置的。

请检查你的s[i]是什么内容，还有第二个sscanf少了一个d，是%d！================"%fl" 你写反了,是lf( long float)sscanf(...,"%lf ",d);可以读具体你看下面的msdn吧Read formatted data from a string. These functions are deprecated because more secure versions are available; see sscanf_s, _sscanf_s_l, swscanf_s, _swscanf_s_l.int sscanf( const char *buffer, const char *format [, argument ] ... );int _sscanf_l( const char *buffer, const char *format, locale_t locale [, argument ] ... );int swscanf( const wchar_t *buffer, const wchar_t *format [, argument ] ... );int _swscanf_l( const wchar_t *buffer, const wchar_t *format, locale_t locale [, argument ] ... );ParametersbufferStored dataformatFormat-control string. For more information, see Format Specifications.argumentOptional argumentslocaleThe locale to useReturn ValueEach of these functions returns the number of fields successfully 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 the string is reached before the first conversion.If buffer or format is a NULL pointer, the invalid parameter handler is invoked, as described in Parameter Validation. If execution is allowed to continue, these functions return -1 and set errno to EINVAL.For information on these and other error codes, see _doserrno, errno, _sys_errlist, and _sys_nerr.RemarksThe sscanf function reads data from buffer into the location given by each argument. Every argument must be a pointer to a variable with a type that corresponds to a type specifier in format. The format argument controls the interpretation of the input fields and has the same form and function as the format argument for the scanf function. If copying takes place between strings that overlap, the behavior is undefined.Security Note When reading a string with sscanf, always specify a width for the %s format (for example, "%32s" instead of "%s"); otherwise, improperly formatted input can easily cause a buffer overrun.swscanf is a wide-character version of sscanf; the arguments to swscanf are wide-character strings. sscanf does not handle multibyte hexadecimal characters. swscanf does not handle Unicode full-width hexadecimal or "compatibility zone" characters. Otherwise, swscanf and sscanf behave identically.The versions of these functions with the _l suffix are identical except that they use the locale parameter passed in instead of the current thread locale.Generic-Text Routine MappingsTCHAR.H routine _UNICODE & _MBCS not defined _MBCS defined _UNICODE defined _stscanf sscanf sscanf swscanf_stscanf_l _sscanf_l _sscanf_l _swscanf_lRequirementsRoutine Required header Compatibility sscanf, _sscanf_l <stdio.h> ANSI, Windows 95, Windows 98, Windows 98 Second Edition, Windows Millennium Edition, Windows NT 4.0, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003swscanf, _swscanf_l <stdio.h> or <wchar.h> ANSI, Windows 95, Windows 98, Windows 98 Second Edition, Windows Millennium Edition, Windows NT 4.0, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003For additional compatibility information, see Compatibility in the Introduction.Example Copy Code // crt_sscanf.c// compile with: /W1// This program uses sscanf to read data items// from a string named tokenstring, then displays them.#include <stdio.h>int main( void ){ char tokenstring[] = "15 12 14..."; char s[81]; char c; int i; float fp; // Input various data from tokenstring: // max 80 character string: sscanf( tokenstring, "%80s", s ); // C4996 sscanf( tokenstring, "%c", &c ); // C4996 sscanf( tokenstring, "%d", &i ); // C4996 sscanf( tokenstring, "%f", &fp ); // C4996 // Note: sscanf is deprecated; consider using sscanf_s instead // Output the data read printf( "String = %s ", s ); printf( "Character = %c ", c ); printf( "Integer: = %d ", i ); printf( "Real: = %f ", fp );}OutputString = 15Character = 1Integer: = 15Real: = 15.000000.NET Framework EquivalentSee Parse methods, such as System::Double::Parse.See AlsoReferenceStream I/Ofscanf, _fscanf_l, fwscanf, _fwscanf_lscanf, _scanf_l, wscanf, _wscanf_lsprintf, _sprintf_l, swprintf, _swprintf_l, __swprintf_l_snprintf, _snprintf_l, _snwprintf, _snwprintf_l地址：ms-help://MS.VSCC.v80/MS.MSDN.v80/MS.VisualStudio.v80.chs/dv_vccrt/html/c2dcf0d2-9798-499f-a4a8-06f7e2b9a80c.htm

别费脑筋了，另想办法吧！两个逗号间本无数据，你怎么能叫sscanf读出个“空”来——这真叫“无中生有”！给你个思路：写个函数一个数据一个数据读，当遇到两个或多个连续逗号时在两个逗号间给接收变量附加一个“空”。

可以使用插入和提取操作符来实现C语言中的对应功能。 在C++中，C语言的格式化输入输出函数scanf和printf函数被转换成对cin和cout对象的插入和提取操作。即cin>>和cout和 a >> b; sprintf的转换也是类似的。

%[^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 | " " | " " | " " | 非%符号} 　　注：　　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 ", buf);　　结果为：123456　　2. 取指定长度的字符串。如在下例中，取最大长度为4字节的字符串。　　sscanf("123456 ", "%4s", buf);　　printf("%s ", buf);　　结果为：1234 　　3. 取到指定字符为止的字符串。如在下例中，取遇到空格为止字符串。　　sscanf("123456 abcdedf", "%[^ ]", buf);　　printf("%s ", buf);　　结果为：123456 　　4. 取仅包含指定字符集的字符串。如在下例中，取仅包含1到9和小写字母的字符串。　　sscanf("123456abcdedfBCDEF", "%[1-9a-z]", buf);　　printf("%s ", buf);　　结果为：123456abcdedf 　　5. 取到指定字符集为止的字符串。如在下例中，取遇到大写字母为止的字符串。　　sscanf("123456abcdedfBCDEF", "%[^A-Z]", buf);　　printf("%s ", buf);　　结果为：123456abcdedf 　　6、给定一个字符串iios/12DDWDFF@122，获取 / 和 @ 之间的字符串，先将 "iios/"过滤掉，再将非"@"的一串内容送到buf中　　sscanf("iios/12DDWDFF@122", "%*[^/]/%[^@]", buf);　　printf("%s ", buf);　　结果为：12DDWDFF 　　7、给定一个字符串““hello, world”，仅保留world。（注意：“，”之后有一空格）　　sscanf(“hello, world”, "%*s%s", buf); 　　printf("%s ", 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 <stdio.h> 　　int main() 　　{ 　　const char* s = "iios/12DDWDFF@122"; 　　char buf[20]; 　　sscanf( s, "%*[^/]/%[^@]", buf ); 　　printf( "%s ", buf ); 　　return 0; 　　} 　　结果为:12DDWDFF 　　sscanf与scanf类似，都是用于输入的，只是后者以屏幕(stdin)为输入源，前者以固定字符串为输入源。 　　函数原型： 　　int scanf( const char *format [,argument]... ); 　　其中的format可以是一个或多个 {%[*] [width] [{h | l | I64 | L}]type | " " | " " | " " | 非%符号}， 　　注：{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 ", buf ); 　　由例子3－》取到指定字符为止的字符串。如在下例中，取遇到空格为止字符串。　　sscanf("123456 abcdedf", "%[^ ]", buf);　　printf("%s ", buf);　　结果为：123456 　　所以周星星的代码总结应该为：　　const char* s = "iios/12DDWDFF@122";　　char buf[20];　　sscanf( s, "%*[^/]/%[^@]", buf );　　printf( "%s ", buf );　　先将 "iios/"过滤掉，再将到字符"@"为止的一串12DDWDFF（由例3可得此串到@为止，把@122舍掉）内容即是：12DDWDFF送到buf中，得到结果。

sscanf(cmt,"%*[^0-9]%[0-9]",imt);sscanf(cmt,"%*[^0-9]%[0-9]",imf);

int i=0, j=0;sscanf("ABCD_12_21_S", "ABCD_%d_%d_S", &i, &j);

给你简化一下问题，专注如何读：char str[200]= "$GPGGA,102639.00,3906.89667,N,11720.83367,E,1,4,4.14,505.0,M,-2.3,M,,*7C";double x,y,x2,y2;char s1[10],s2[10], s3[10];以逗号为分格符，要读一个字符串用：sscanf(str,"%[^","],%lf, %lf,%[^","],%lf,%[^","],%lf",s1,&x,&y,s2,&x2,s3,&y2);以逗号为分格符，跳过一个字符串用：sscanf(str,"%*[^","],%lf, %lf,%*[^","],%lf,%*[^","],%lf",&x,&y,&x2,&y2);===========注意，跳过用 %*[^","] ，后面无 s1 。。。读 用 %[^","] ， 后面有 s1 。。。其它问题也解决了。

sscanf 是从字符串中读取数据，对于书名，已经是字符串了，不必读，只要知道下标位置就可以了。键盘输入带空格的字符串，用 gets() 读一行 就可以了。字符串比较 可以 用 strcmp 或 strncmp， 后者 你可以比较长度为 strlen(book_name) 的字符串。

#include <strstream>std::ostrstream ostr;ostr << abc << " " << de << "";std::cout << ostr.str() << std::endl;sprintf 可以用ostrstream替代. 记住以结尾, sscanf同理可以以istrstream代替

C语言sscanf函数的总结在处理字符串的程序当中，经常会分析字符串，从一大长串的字符串截取我们需要的数据，这如果通过自己手写函数来分析，虽然可以，但当你知道sscanf的功能，那就自己写函数分析就显得多此一举。这些函数的使用都很简单，总结一下，等下次使用一目了然。俗话说：好记性不如烂笔头，记录下来就是效率。以下源代码是本人测试的源文件，附带讲解注释。1./***************************************************** 2.** Name : sscanf.c 3.** Author : gzshun 4.** Version : 1.0 5.** Date : 2011-12 6.** Description : sscanf function 7.******************************************************/ 8.#include <stdio.h> 9.#include <stdlib.h> 10.#include <string.h> 11. 12.static void sscanf_test(void); 13. 14.static void sscanf_test(void) 15.{ 16. int ret; 17. char *string; 18. int digit; 19. char buf1[255]; 20. char buf2[255]; 21. char buf3[255]; 22. char buf4[255]; 23. 24. /*1.最简单的用法*/ 25. string = "china beijing 123"; 26. ret = sscanf(string, "%s %s %d", buf1, buf2, &digit); 27. printf("1.string=%s ", string); 28. printf("1.ret=%d, buf1=%s, buf2=%s, digit=%d ", ret, buf1, buf2, digit); 29. /* 30. **执行结果: 31. **1.ret=2, buf1=china, buf2=beijing, digit=123 32. **可以看出,sscanf的返回值是读取的参数个数 33. */ 34. 35. /*2.取指定长度的字符串*/ 36. string = "123456789"; 37. sscanf(string, "%5s", buf1); 38. printf("2.string=%s ", string); 39. printf("2.buf1=%s ", buf1); 40. /* 41. **执行结果: 42. **2.buf1=12345 43. */ 44. 45. /*3.取到指定字符为止的字符串*/ 46. string = "123/456"; 47. sscanf(string, "%[^/]", buf1); 48. printf("3.string=%s ", string); 49. printf("3.buf1=%s ", buf1); 50. /* 51. **执行结果: 52. **3.buf1=123 53. */ 54. 55. /*4.取到指定字符集为止的字符串*/ 56. string = "123abcABC"; 57. sscanf(string, "%[^A-Z]", buf1); 58. printf("4.string=%s ", string); 59. printf("4.buf1=%s ", buf1); 60. /* 61. **执行结果: 62. **4.buf1=123abc 63. */ 64. 65. /*5.取仅包含指定字符集的字符串*/ 66. string = "0123abcABC"; 67. sscanf(string, "%[0-9]%[a-z]%[A-Z]", buf1, buf2, buf3); 68. printf("5.string=%s ", string); 69. printf("5.buf1=%s, buf2=%s, buf3=%s ", buf1, buf2, buf3); 70. /* 71. **执行结果: 72. **5.buf1=123 73. */ 74. 75. /*6.获取指定字符中间的字符串*/ 76. string = "ios<Android>wp7"; 77. sscanf(string, "%*[^<]<%[^>]", buf1); 78. printf("6.string=%s ", string); 79. printf("6.buf1=%s ", buf1); 80. /* 81. **执行结果: 82. **6.buf1=android 83. */ 84. 85. /*7.指定要跳过的字符串*/ 86. string = "iosVSandroid"; 87. sscanf(string, "%[a-z]VS%[a-z]", buf1, buf2); 88. printf("7.string=%s ", string); 89. printf("7.buf1=%s, buf2=%s ", buf1, buf2); 90. /* 91. **执行结果: 92. **7.buf1=ios, buf2=android 93. */ 94. 95. /*8.分割以某字符隔开的字符串*/ 96. string = "android-iphone-wp7"; 97. /* 98. **字符串取道"-"为止,后面还需要跟着分隔符"-", 99. **起到过滤作用,有点类似于第7点 100. */ 101. sscanf(string, "%[^-]-%[^-]-%[^-]", buf1, buf2, buf3); 102. printf("8.string=%s ", string); 103. printf("8.buf1=%s, buf2=%s, buf3=%s ", buf1, buf2, buf3); 104. /* 105. **执行结果: 106. **8.buf1=android, buf2=iphone, buf3=wp7 107. */ 108. 109. /*9.提取邮箱地址*/ 110. string = "Email:beijing@sina.com.cn"; 111. sscanf(string, "%[^:]:%[^@]@%[^.].%s", buf1, buf2, buf3, buf4); 112. printf("9.string=%s ", string); 113. printf("9.buf1=%s, buf2=%s, buf3=%s, buf4=%s ", buf1, buf2, buf3, buf4); 114. /* 115. **执行结果: 116. **9.buf1=Email, buf2=beijing, buf3=sina, buf4=com.cn 117. */ 118.} 119. 120.int main(int argc, char **argv) 121.{ 122. sscanf_test(); 123. 124. return 0; 125.} 126. 127./* 128.**测试程序 129.**环境: 130.**Linux Ubuntu 2.6.32-24-generic-pae #39-Ubuntu SMP Wed Jul 28 07:39:26 UTC 2010 i686 GNU/Linux 131.**gcc version 4.4.3 (Ubuntu 4.4.3-4ubuntu5) 132.** 133.gzshun@ubuntu:~/c/sscanf$ gcc sscanf.c -o sscanf 134.gzshun@ubuntu:~/c/sscanf$ ./sscanf 135.1.string=china beijing 123 136.1.ret=3, buf1=china, buf2=beijing, digit=123 137. 138.2.string=123456789 139.2.buf1=12345 140. 141.3.string=123/456 142.3.buf1=123 143. 144.4.string=123abcABC 145.4.buf1=123abc 146. 147.5.string=0123abcABC 148.5.buf1=0123, buf2=abc, buf3=ABC 149. 150.6.string=ios<android>wp7 151.6.buf1=android 152. 153.7.string=iosVSandroid 154.7.buf1=ios, buf2=android 155. 156.8.string=android-iphone-wp7 157.8.buf1=android, buf2=iphone, buf3=wp7 158. 159.9.string=Email:beijing@sina.com.cn 160.9.buf1=Email, buf2=beijing, buf3=sina, buf4=com.cn 161.*/ 本篇文章来源于 Linux公社网站(www.linuxidc.com) 原文链接：http://www.linuxidc.com/Linux/2011-12/49711.htm

那就别指望sscanf了，它是以空格、回车、横制表符等作为字符串间的分隔符的，就是说遇到空格等时就认为前面的字符串输入完毕了，并将其正确读入。要想得到有空格的字符串可以选择gets、fgets等，也可以自己写一段代码或函数实现。

sscanf（）是格式化输入字符，比如%s是按照字符串格式，%d是十进制整数。read（）是读文件，吧文件的内容读出来放进一个指针中，可以是常指针，比如数组名等

头文件 #include 定义函数 int sscanf (const char *str,const char * format,........); 函数说明 sscanf()会将参数str的字符串根据参数format字符串来转换并格式化数据。格式转换形式请参考scanf()。转换后的结果存于对应的参数内。 返回值 成功则返回参数数目，失败则返回-1，错误原因存于errno中。 返回0表示失败 否则，表示正确格式化数据的个数 例如：sscanf(str，"%d%d%s", &i,&i2, &s); 如果三个变成都读入成功会返回3。 如果只读入了第一个整数到i则会返回1。证明无法从str读入第二个整数。 范例 #include main() { int i; unsigned int j; char input[ ]=”10 0x1b aaaaaaaa bbbbbbbb”; char s[5]; sscanf(input,”%d %x %5[a-z] %*s %f”,&i,&j,s,s); printf(“%d %d %s ”,i,j,s); } 执行 10 27 aaaaa sscanf(stringBuf.c_str(), "%20[^#]#%20[^ ]",......)语句中""中的内容含义为： “%[ ]”符号用于声明字符串，它比“%s”更具体，可以用于设置读取的样式。例如“%[a-z]”只读取小写字母，读到其它字符就结束。注意，方括号中如果有“^”，代表一直读到某字符为止。例如： “%[^#]”：读取字符串，一直到出现“＃”号为止。 “%20[^#]”：读取20个字节的字符串，出现“＃”号时结束。 所以，“%20[^#]#%20[^ ]”的意义就是， 读取两个20字节大小的字符串，第一个字符串可以用＃结束，第二个字符串可以用回车符结束。

1、当然能。sscanf相当于格式输入，能够处理任何特殊格式的输入。2、例如：#include <stdio.h>int main(){char abd[80]="aaabc.jpg";char buf1[10],buf2[10];sscanf(abd, "%[^.].%[^.]", buf1, buf2); //通过ssanf获得文件名及后缀名printf("buf1=%s buf2=%s",buf1, buf2);}

char buff[512];sscanf("basis= 24 time is up","%[1-9]",buf); //取出整数printf("%s ",buf);int a=0;a=atoi(buff); //将数字字符串转化为整数

%[^&]的意思是指输入的数据要遇上&才结束；比如说在处理字符串中的scanf("%s",a);如果普通的话遇上了空格或者回车就结束了；但把它改成这个样子scanf("%[^=]",a);就表示在输入数据中是以‘="为结束标志的。在遇到空格和回车都不结束当前输入。这句话有意思的地方就在于当使用这种特殊结束标志以后，这个标志不但不会被存储在对应的存储空间里，而且输出的时候按照普通方法即可输出所输入的字符；比如我说，我输入了：sdfasf asdfasf adf asfadsffds =使用printf("%s",a)；它就会按照原样式输出到"=‘前的位置；

sscanf() - 从一个字符串中读进与指定格式相符的数据. 函数原型:int sscanf( string str, string fmt, mixed var1, mixed var2 ... );sscanf与scanf类似，都是用于输入的，只是后者以键盘(stdin)为输入源，前者以固定字符串为输入源。 其中的format可以是一个或多个 {%[*] [width] [{h | l | I64 | L}]type | " " | " " | " " | 非%符号} 注： 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的任意字符，贪婪性它强大的功能体现在对format的支持上。 例如你程序中要分离IP地址，由于IP地址字段以“。”分隔，所以可以通过设置格式化形式分离，正如你写的sscanf(pTrustedIp,"%d.%d.%d.%d",&x[0],&x[1],&x[2],&x[3]);则192会被分离写入x[0],168则分离写入x[1],如下的对应，所以你所说的情况不会出现

主要有两个方法，其实都是对现有函数的使用：方法1: sscanf()函数名: sscanf功 能: 从字符串格式化输入用 法: int sscanf(char *string, char *format[,argument,...]);以上的 format 为 %x 就是将字符串格式化为 16 进制数例子：#include <stdio.h>void main(){char* p = "0x1a";int nValude = 0;sscanf(p, "%x", &nValude);printf("%d ", nValude);}输出：26方法2: strtol()函数名: strtol功 能: 将字符串转换为长整数用 法: long strtol(char *str, char **endptr, int base);上面的base就是我们要转换为几进制数例子：#include <stdio.h>#include <stdlib.h>void main(){char* p = "0x1b";char* str;long i = strtol(p, &str, 16);printf("%d ", i);}输出：27其实还有一种方法，就是用一个初始化为0~9~a~f的字符串数组，也就是一个十六进制对应表，用这个对应表即可算出一个十六进制字符串的数值，但这种发发太麻烦了，不推荐使用。

驱动属于内核，在内核空间里没有C库，所以没有sscanf，printf。

用 : 来分隔即可char* url = "<spia:xingtom@17a2.18.1.133>";char uri[10] = {0};sscanf(url, "%*[^:]:xing%[^@17a2]", uri);printf("%s ",uri);

scanf("%d",&N);返回1， scanf（"%d%d",&m,&n） 返回2， 明白么？ 就是返回值个数

没有sscanf()，但有用来从字符串取出数字的函数Left$(C,N) 在字符串C中从左边截取N个字符 Left$("ABCDEF",3)="ABC"Right$(C,N) 在字符串C中从右边截取N个字符 Left$("ABCDEF",3)="DEF" 至于取出数字，用Val,如A=Val(Text1.Text)

你想显示一个字符串吧？你第一个参数用的有问题。第一个参数应该是个buffer。char*pBuffr=newchar[5];memset(pBuffr,"0",sizeof(char)*5);sscanf(pBuffr,"%2X,%4X",&a,&b);

sscanf 是字符串格式化函数。%s是最简单的实现，其实你这个语句就等于是字符串拼接，将buffer内容和引号中的内容拼接后给digit。假如buffer是“abcdef"，那么执行后digit就是”ABCDEF=abcdef"。http://baike.baidu.com/view/1364018.htm这里有很详细的说明和例子了，自己慢慢看看。

是不是只读出第一个数字？sscanf的第一个参数(字符串指针)要不断增加。否则永远读出来的第一个。

请明确一下您的问题：1.如果你是在纯matlab环境下实现某种功能，那么：matlab跟c没有直接的关系，不可能在matlab里“重载”c函数，matlab本身更没有什么流的概念。如果不清楚matlab里sscanf的用法，请输入命令helpsscanf。2.如果你是说在用mex方法写一段可以被matlab调用的c程序，那么：我不知道您为什么在纠结“matlab里没有地址符”的问题。这种mex式的c程序里本来也没有matlab的语法写任何东西。3.如果你是在c环境下调用matlab的库，那么：我完全不知道您在说什么。不过看您的问题也不像是这种情况。