标签：
在将各种类型的数据构造成字符串时，sprintf 的强大功能很少会让你失望。由于sprintf 跟printf 在用法上几乎一样，只是打印的目的地不同而已，前者打印到字符串中，后者则直接在命令行上输出。这也导致sprintf 比printf 有用得多。
printf
语法:
#include <stdio.h>
int printf( const char *format, ... );
printf()函数根据format(格式)给出的格式打印输出到STDOUT(标准输出)和其它参数中。返回值是输出的字符数量。
sprintf
语法:
#include <stdio.h>
int sprintf( char *buffer, const char *format, ... );
sprintf()函数和printf()类似，格式控制完全一样，只要是printf使用的格式化字符串，在sprintf都可以使用，只是把输出发送到buffer(缓冲区)中。返回值是写入的字符数量。
功能一：格式化数字字符串
sprintf(s, "%-8X", 12345); //s变成：“12345 ”
大写的“X”代表，16进制大写形式，宽度占8 个位置，“-”代表左对齐 。
功能二：控制浮点数打印格式
浮点数使用格式符”%f”控制，默认保留小数点后6 位数字 %m.nf”格式，其中m 表示打印的宽度，n 表示小数点后的位数
sprintf(s, "%10.3f", 3.1415626); //s变成：" 3.142"
功能三：连接两个字符串
直接连接：
char dest[256];
char src1[] = {‘a‘,‘b‘,‘c‘,‘d‘,‘e‘};
char src2[] ={‘1‘,‘2‘,‘3‘,‘4‘};s
printf(dest,"%.5s%.4s",src1,src2); //output:“abcde1234”
截取字符串的某一些字符进行连接，
char dest[256];
char src1[] = {‘a‘,‘b‘,‘c‘,‘d‘,‘e‘};
char src2[] ={‘1‘,‘2‘,‘3‘,‘4‘};
sprintf(dest,"%.*s%.*s",2,src1,3,src2); //output:“ab123”
功能四：字符/Ascii 码对照
我们知道，使用”%d”或者”%x”打印一个字符，便能得出它的10 进制或16 进制的ASCII 码；反过来，使用”%c”打印一个整数，便可以看到它所对应的ASCII 字符。以下程序段把所有可见字符的ASCII 码对照表打印到屏幕上（这里采用printf，注意”#”与”%X”合用时自动为16 进制数增加”0X”前缀）：
for(int i = 32; i < 127; i++) {
printf("[ %c ]: %3d 0x%#04X\n", i, i, i);
}
功能五：打印地址信息
有时调试程序时，我们可能想查看某些变量或者成员的地址，由于地址或者指针也不过是个32 位的数，你完全可以使用打印无符号整数的”%u”把他们打印出来：
sprintf(s, "%u", &i);
不过通常人们还是喜欢使用16 进制而不是10 进制来显示一个地址：
sprintf(s, "%08X", &i);
然而，这些都是间接的方法，对于地址打印，sprintf 提供了专门的”%p”：
sprintf(s, "%p", &i);
我觉得它实际上就相当于：
sprintf(s, "%0*x", 2 * sizeof(void *), &i);
功能六：利用返回值
printf与sprintf的返回值是写入的字符数量。
也就是说每当一次sprinf 调用结束以后，你无须再调用一次strlen 便已经知道了结果字符串的长度。如：
int len = sprintf(s, "%d", i);
scanf
语法:
#include <stdio.h>
int scanf( const char *format, ... );
scanf()函数根据由format(格式)指定的格式从stdin(标准输入)读取,并保存数据到其它参数.
sscanf
语法:
#include <stdio.h>
int sscanf( const char *buffer, const char *format, ... );
函数sscanf()和scanf()类似, 只是输入从buffer(缓冲区)中读取.
sscanf与scanf类似，都是用于输入的，只是后者以屏幕(stdin)为输入源，前者以固定字符串为输入源
用法：
%[ ]表示要读入一个字符集合, 如果[ 后面第一个字符是”^”，则表示反意思。[ ]内的字符串可以是1或更多字符组成。空字符集（%[]）是违反规定的，可导致不可预知的结果。%[^]也是违反规定的。
%[a-z] 读取在 a-z 之间的字符串，如果不在此之前则停止，如
char s[]="hello, my friend” ; // 注意: ,逗号在不 a-z之间
sscanf( s, “%[a-z]”, string ) ; // string=hello
%[^a-z] 读取不在 a-z 之间的字符串，如果碰到a-z之间的字符则停止，如
char s[]="HELLOkitty” ; // 注意: ,逗号在不 a-z之间
sscanf( s, “%[^a-z]”, string ) ; // string=HELLO
%*[^=] 前面带 * 号表示不保存变量。跳过符合条件的字符串。
char s[]="notepad=1.0.0.1001" ;
char szfilename [32] = "" ;
int i = sscanf( s, "%*[^=]", szfilename ) ;// szfilename=NULL,因为没保存
intj = sscanf( s, "%*[^=]=%s", szfilename ) ;// szfilename=1.0.0.1001
%40c 读取40个字符
%[^=] 读取字符串直到碰到‘=‘号，‘^‘后面可以带更多字符,如：
char s[]="notepad=1.0.0.1001" ;
char szfilename [32] = "" ;
int i = sscanf( s, "%[^=]", szfilename ) ; // szfilename=notepad
如果参数格式是：%[^=:] ，那么也可以从 notepad:1.0.0.1001读取notepad
引用：http://blog.csdn.net/njutony1991/article/details/6198046
1：
sprintf 最常见的应用之一莫过于把整数打印到字符串中，所以，spritnf
在大多数场合可以替代itoa。
这样，一个整数的16 进制字符串就很容易得到，但我们在打印16 进制内容
时，通常想要一种左边补0 的等宽格式，那该怎么做呢？很简单，在表示宽
度的数字前面加个0 就可以了。
sprintf(s, "%08X", 4567); //产生："000011D7"
上面以”%d”进行的10 进制打印同样也可以使用这种左边补0 的方式。
这里要注意一个符号扩展的问题：比如，假如我们想打印短整数（short）-1
的内存16 进制表示形式，在Win32 平台上，一个short 型占2 个字节，所
以我们自然希望用4 个16 进制数字来打印它：
short si = -1;
sprintf(s, "%04X", si);
产生“FFFFFFFF”，怎么回事？因为spritnf 是个变参函数，除了前面两个
参数之外，后面的参数都不是类型安全的，函数更没有办法仅仅通过一个
“%X”就能得知当初函数调用前参数压栈时被压进来的到底是个4 字节的整
数还是个2 字节的短整数，所以采取了统一4 字节的处理方式，导致参数压
栈时做了符号扩展，扩展成了32 位的整数-1，打印时4 个位置不够了，就
把32 位整数-1 的8 位16 进制都打印出来了。如果你想看si 的本来面目，
那么就应该让编译器做0 扩展而不是符号扩展（扩展时二进制左边补0 而不
是补符号位）：
sprintf(s, "%04X", (unsigned short)si);
就可以了。或者：
unsigned short si = -1;
sprintf(s, "%04X", si);
2：
浮点数的打印和格式控制是sprintf 的又一大常用功能，浮点数使用格式符”
%f”控制，默认保留小数点后6 位数字，比如：
sprintf(s, "%f", 3.1415926); //产生"3.141593"
但有时我们希望自己控制打印的宽度和小数位数，这时就应该使用：”
%m.nf”格式，其中m 表示打印的宽度，n 表示小数点后的位数。比如：
sprintf(s, "%10.3f", 3.1415626); //产生：" 3.142"
sprintf(s, "%-10.3f", 3.1415626); //产生："3.142 "
sprintf(s, "%.3f", 3.1415626); //不指定总宽度，产生："3.142"
注意一个问题，你猜
int i = 100;
sprintf(s, "%.2f", i);
会打出什么东东来？“100.00”？对吗？自己试试就知道了，同时也试试下面这个：
sprintf(s, "%.2f", (double)i);
第一个打出来的肯定不是正确结果，原因跟前面提到的一样，参数压栈时调
用者并不知道跟i相对应的格式控制符是个”%f”。而函数执行时函数本身
则并不知道当年被压入栈里的是个整数，于是可怜的保存整数i 的那4 个字
节就被不由分说地强行作为浮点数格式来解释了，整个乱套了。
3:
连接字符串
sprintf 的格式控制串中既然可以插入各种东西，并最终把它们“连成一
串”，自然也就能够连接字符串，从而在许多场合可以替代strcat，但
sprintf 能够一次连接多个字符串（自然也可以同时在它们中间插入别的内
容，总之非常灵活）。比如：
char* who = "I";
char* whom = "CSDN";
sprintf(s, "%s love %s.", who, whom); //产生："I love CSDN. "
还可以是各种数据类型的整合，如
char cfile_name[100];
sprintf(cfile_name,"%d%s",v_count,"model.txt");
strcat 只能连接字符串（一段以’’结尾的字符数组或叫做字符缓冲，
null-terminated-string），
但有时我们有两段字符缓冲区，他们并不是以’’结尾。比如许多从第三
方库函数中返回的字符数组，从硬件或者网络传输中读进来的字符流，它们
未必每一段字符序列后面都有个相应的’’来结尾。如果直接连接，不管
是sprintf 还是strcat 肯定会导致非法内存操作，strncat 也至少要求第
一个参数是个null-terminated-string，那该怎么办呢？我们自然会想起前
面介绍打印整数和浮点数时可以指定宽度，字符串也一样的。比如：
char a1[] = {’A‘, ‘B’, ‘C’, ‘D’, ‘E’, ‘F’, ‘G’};
char a2[] = {’H‘, ‘I’, ‘J’, ‘K’, ‘L’, ‘M’, ‘N’};
如果：
sprintf(s, "%s%s", a1, a2); //Don’t do that!
十有八九要出问题了。是否可以改成：
sprintf(s, "%7s%7s", a1, a2);
也没好到哪儿去，正确的应该是：
sprintf(s, "%.7s%.7s", a1, a2);//产生："ABCDEFGHIJKLMN"
这可以类比打印浮点数的”%m.nf”，在”%m.ns”中，m 表示占用宽度（字
符串长度不足时补空格，超出了则按照实际宽度打印），n 才表示从相应的
字符串中最多取用的字符数。通常在打印字符串时m 没什么大用，还是点号
后面的n 用的多。自然，也可以前后都只取部分字符：
sprintf(s, "%.6s%.5s", a1, a2);//产生："ABCDEFHIJKL"
(因为sprintf函数将输出写入到字符串s中，并以”结束，所以生成的s
中有”，所以可以用printf(s),而不用担心会出错)
在许多时候，我们或许还希望这些格式控制符中用以指定长度信息的数字是
动态的，而不是静态指定的，因为许多时候，程序要到运行时才会清楚到底
需要取字符数组中的几个字符，这种动态的宽度/精度设置功能在sprintf
的实现中也被考虑到了，sprintf 采用”*”来占用一个本来需要一个指定
宽度或精度的常数数字的位置，同样，而实际的宽度或精度就可以和其它被
打印的变量一样被提供出来，于是，上面的例子可以变成：
sprintf(s, "%.*s%.*s", 7, a1, 7, a2);
或者：
sprintf(s, "%.*s%.*s", sizeof(a1), a1, sizeof(a2), a2);
实际上，前面介绍的打印字符、整数、浮点数等都可以动态指定那些常量值，
比如：
sprintf(s, "%-*d", 4, ‘A’); //产生"65 "
sprintf(s, "%#0*X", 8, 128); //产生"0X000080"，"#"产生0X
sprintf(s, "%*.*f", 10, 2, 3.1415926); //产生" 3.14"
二， sscanf
MSDN 中sscanf的使用说明
sscanf, swscanf
Read formatted data from a string.
int sscanf( const char *buffer, const char *format [, argument ] … );
int swscanf( const wchar_t *buffer, const wchar_t *format [, argument ] … );
Routine Required Header Compatibility
sscanf <stdio.h> ANSI, Win 95, Win NT
swscanf <stdio.h> or <wchar.h> ANSI, Win 95, Win NT
For additional compatibility information, see Compatibility in the Introduction.
Libraries
LIBC.LIB Single thread static library, retail version
LIBCMT.LIB Multithread static library, retail version
MSVCRT.LIB Import library for MSVCRT.DLL, retail version
Return Value
Each 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.
Parameters
buffer
Stored data
format
Format-control string
argument
Optional arguments
For more information, see Format Specifications.
Remarks
The 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; see scanf for a complete description of format. If copying takes place between strings that overlap, the behavior is undefined.
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 fullwidth hexadecimal or “compatibility zone” characters. Otherwise, swscanf and sscanf behave identically.
Generic-Text Routine Mappings
TCHAR.H Routine _UNICODE & _MBCS Not Defined _MBCS Defined _UNICODE Defined
_stscanf sscanf sscanf swscanf
Example
/* SSCANF.C: This program uses sscanf to read data items
* from a string named tokenstring, then displays them.
*/
#include <stdio.h>
void main( void )
{
char tokenstring[] = "15 12 14…";
char s[81];
char c;
int i;
float fp;
/* Input various data from tokenstring: */
sscanf( tokenstring, "%s", s );
sscanf( tokenstring, "%c", &c );
sscanf( tokenstring, "%d", &i );
sscanf( tokenstring, "%f", &fp );
char typestring[] = "15, 12; 14.1";
sscanf( typestring, "%s, %d; %f", s, &c, &fp);
/* Output the data read */
printf( "String = %s/n", s );
printf( "Character = %c/n", c );
printf( "Integer: = %d/n", i );
printf( "Real: = %f/n", fp );
}
Output
String = 15
Character = 1
Integer: = 15
Real: = 15.000000
引用：http://www.cnblogs.com/Anker/p/3351168.html
1、前言
我们经常涉及到数字与字符串之间的转换，例如将32位无符号整数的ip地址转换为点分十进制的ip地址字符串，或者反过来。从给定的字符串中提取相关内容，例如给定一个地址：http://www.bokeyuan.cn:2345，我们要从地址中提出协议，主机地址和端口号。之前对字符串和数字之间的关系不是很熟悉，工作中经常涉及到这个，如是好好总结一下。C语言提供了一些列的格式化输入输出函数，最基本的是面向控制台标准输出和输入的printf和scanf，其实还有面向字符串的sprint和sscanf，面向文件的流的fprintf和fscanf。今天着重总结一下sprintf和sscanf系列函数，这两个函数类似于scanf和printf ，不同点是从字符串*buffer用于输入输出。
2、sprintf函数
sprintf函数原型为 int sprintf(char *str, const char *format, ...)。作用是格式化字符串，具体功能如下所示：
（1）将数字变量转换为字符串。
（2）得到整型变量的16进制和8进制字符串。
（3）连接多个字符串。
举例如下所示：
1 char str[256] = { 0 };
2 int data = 1024;
3 //将data转换为字符串
4 sprintf(str,"%d",data);
5 //获取data的十六进制
6 sprintf(str,"0x%X",data);
7 //获取data的八进制
8 sprintf(str,"0%o",data);
9 const char *s1 = "Hello";
10 const char *s2 = "World";
11 //连接字符串s1和s2
12 sprintf(str,"%s %s",s1,s2);
3、sscanf函数
sscanf函数原型为int sscanf(const char *str, const char *format, ...)。将参数str的字符串根据参数format字符串来转换并格式化数据，转换后的结果存于对应的参数内。具体功能如下：
（1）根据格式从字符串中提取数据。如从字符串中取出整数、浮点数和字符串等。
（2）取指定长度的字符串
（3）取到指定字符为止的字符串
（4）取仅包含指定字符集的字符串
（5）取到指定字符集为止的字符串
sscanf可以支持格式字符%[]：
(1)-: 表示范围，如：%[1-9]表示只读取1-9这几个数字 %[a-z]表示只读取a-z小写字母，类似地 %[A-Z]只读取大写字母
(2)^: 表示不取，如：%[^1]表示读取除‘1‘以外的所有字符 %[^/]表示除/以外的所有字符
(3),: 范围可以用","相连接 如%[1-9,a-z]表示同时取1-9数字和a-z小写字母
(4)原则：从第一个在指定范围内的数字开始读取，到第一个不在范围内的数字结束%s 可以看成%[] 的一个特例 %[^ ](注意^后面有一个空格！)
解析网址的例子如下所示：
1 const char *s = "http://www.baidu.com:1234";
2 char protocol[32] = { 0 };
3 char host[128] = { 0 };
4 char port[8] = { 0 };
5 sscanf(s,"%[^:]://%[^:]:%[1-9]",protocol,host,port);
6
7 printf("protocol: %s\n",protocol);
8 printf("host: %s\n",host);
9 printf("port: %s\n",port);
10
4、snprintf函数
snprintf函数是sprintf函数的更加安全版本，考虑到字符串的字节数，防止了字符串溢出。函数形式为：int snprintf(char *restrict buf, size_t n, const char * restrict format, ...);。最多从源串中拷贝n－1个字符到目标串中，然后再在后面加一个0。所以如果目标串的大小为n 的话，将不会溢出。
5、测试程序
本次采用ip地址和整型之间的转换，mac地址转换作为测试程序，整个程序如下所示：
1 #include <stdio.h>
2 #include <assert.h>
3
4 #define IP_STR_LEN 18
5 #define MAC_STR_LEN 18
6 #define MAC_BIT_LEN 6
7 #define LITTLE_ENDIAN 0
8 #define BIG_ENDIAN 1
9
10 typedef unsigned char uchar;
11 typedef unsigned int uint;
12
13 int big_little_endian()
14 {
15 int data = 0x1;
16 if (*((char*)&data) == 0x1)
17 return LITTLE_ENDIAN;
18 return BIG_ENDIAN;
19 }
20
21 uint ipstr2int(const char * ipstr)
22 {
23 assert(ipstr);
24 uint a,b,c,d;
25 uint ip = 0;
26 sscanf(ipstr,"%u.%u.%u.%u",&a,&b,&c,&d);
27 a = (a << 24) ;
28 b = (b << 16) ;
29 c = (c << 8) ;
30 d = (d << 0) ;
31 ip = a | b | c | d;
32 return ip;
33 }
34
35 char *int2ipstr(const uint ip, char *ipstr, const uint ip_str_len)
36 {
37 assert(ipstr);
38 if (big_little_endian() == LITTLE_ENDIAN)
39 sprintf(ipstr,"%u.%u.%u.%u",
40 (uchar)*((char*)(&ip)+3),
41 (uchar)*((char*)(&ip)+2),
42 (uchar)*((char*)(&ip)+1),
43 (uchar)*((char*)(&ip)+0));
44 else
45 sprintf(ipstr,"%u.%u.%u.%u",
46 (uchar)*((char*)(&ip)+0),
47 (uchar)*((char*)(&ip)+1),
48 (uchar)*((char*)(&ip)+2),
49 (uchar)*((char*)(&ip)+3));
50
51 return ipstr;
52 }
53
55 char *mac2str(const unsigned char *mac,char *mac_str,const uint mac_str_len)
56 {
57 assert(mac_str);
58 sprintf(mac_str,"%02X-%02X-%02X-%02X-%02X-%02X",
59 mac[0],mac[1],mac[2],
60 mac[3],mac[4],mac[5]);
61 }
62
63 int main()
64 {
65 char ip_str[IP_STR_LEN] = {0};
66 char mac_str[MAC_STR_LEN] = {0};
67 unsigned char mac[MAC_BIT_LEN] = {0XEF,0XAD,0XF4,0X4F,0XAA,0X0F};
68 const char *ipstr = "10.0.3.193";
69 unsigned int ip;
70 int2ipstr(167773121,ip_str,IP_STR_LEN);
71 mac2str(mac,mac_str,MAC_STR_LEN);
72 ip = ipstr2int(ipstr);
73 printf("%s\n",ip_str);
74 printf("%s\n",mac_str);
75 printf("ip:%u\n",ip);
76 return 0;
77 }
程序执行结果如下所示：
C语言中的printf(),sprintf(),scanf(),sscanf()
标签：
原文地址：http://blog.csdn.net/smf0504/article/details/51295487
