http://blog.chinaunix.net/uid/29667945/cid-212362-list-1.html
http://blog.chinaunix.net/uid-29667945-id-4957043.html
使用sprintf和strlen时需注意的细节
今天调试程序时出现了错误：malloc(): memory corruption: 0x09fb3da0。上网查询后说可能是内存访问越界。仔细阅读自己写的代码后发现是strlen和sprintf导致的问题。
strlen返回的长度不包括字符串末尾的' '，而sprintf会在字符串末尾自动加上' '。我在动态分配内存的时候，分配了strlen（）长度的内存，然后使用sprintf在分配的内存写入了字符串，由于末尾追加了' '，因此导致越界访问了一个字节。等到再次动态分配内存的时候，就出现了上述错误。
https://www.cnblogs.com/lsgxeva/p/9486414.html
https://github.com/HardySimpson/zlog
https://blog.csdn.net/qq_40008325
C语言中字符串的几种定义方式
char a[5]="hello";
第2种
char a[]="hello";
第3种
char* a="hello";
第4种
char a[10];
gets(a);
第5种
char* a[5]={"hello",
"nihao",
"good",
"ok",
"bye"};
stuNum = '201709080059'
print('年级是：'+stuNum[0:4])
print('专业编号是：'+stuNum[4:9])
print('序号是：'+stuNum[-3:])
IDNo= '511303199807040028'
print('省市是：'+IDNo[0:2])
print('生日是：'+IDNo[-8:-4])
print('性别是：'+IDNo[-2])
我在ubuntu server 11.10上写了如下的代码:
// charc.c
include <stdio.h>
int main(int argc,char** argv){
char* str="I am a student.";
printf("%s
",str);
str[0]='i';
printf("%s
,str);
return 0;
}
使用gcc编译：
gcc -o charc charc.c
当执行 str[0]='i' 时，报“Segmentation fault” 错误.
但如果将char* str="I am a student"换成str[]="I am a student";就没有错。
我要把ulong转换成字符串，我原来用:
ulong x=1000000000;
sprintf(temp,"%10d",x);
不行，应该用什么格式符呢
%u
printf("%c
",*str);//输出首字符
printf("%s
",str);//输出整串字符
printf("%p
",str);//输出字符串首字符地址
printf("%p
",&str);//输出指针str的地址
printf("%d
",integer);//输出integer
gcc中格式化输出函数的研究：http://blog.csdn.net/dai_xiangjun/article/details/41356723
C语言格式化输出小结：http://blog.51cto.com/happyliu/1621709
https://blog.csdn.net/freeking101/article/details/78935559
int main(void)
{
char url_str[1024];
int url_len = 0;
url_len = snprintf(url_str, sizeof(url_str), "%*.*s,5,5,"hello");
printf("url_len is:%s
", url_str);
return 0;
}
刚开始看到 %*.*s 的时候楞了一下，半天没反应过来，后来想了下，这个与"%5.5s,"hello"是等价的。
不过若是这里的5和"hello"要是经常变化的值的话，用 %*.*s 就更方便了。
注: %6.9s 表示显示一个长度不小于6且不大于9的字符串。若大于9, 则第9个字符以后的内容将被删除。
众所周知,sprintf不能检查目标字符串的长度，可能造成众多安全问题,所以都会推荐使用snprintf.
自从snprintf代替了sprintf，相信大家对snprintf的使用都不会少，函数定义如下：
int snprintf(char*str, size_t size,constchar*format, ...);
函数说明:
最多从源串中拷贝size－1个字符到目标串中，然后再在后面加一个0。所以如果目标串的大小为size的话，将不会溢出。
函数返回值:
若成功则返回欲写入的字符串长度，若出错则返回负值。
但是大家在使用snprintf的时候是否真的清楚参数里size的意思呢？看下面的例子：
假设我想将一个char类型的变量打印成2进制，我应该怎么写呢？
之前有个同事这样写的：
char a='a';
char str[20];
snprintf(str,2,"%02x",a);
对不对呢，错了。
1). 2不应该是2，应该是3.
2). 也不建议直接写3，应该写sizeof(str)
所以建议的写法是：
char a='a';
char str[3];//再大点也没有问题
snprintf(str,sizeof(str),"%02x",a);
解释如下：
size是限定最终生成的dest的字符数,最多拷贝size-1个字符; 一般情况下size会取sizeof(dest),这是为了dst不溢出.
在snprintf(dest, size, "str: %s
", src)中如果size-1大于等于"str: %s
"的长度,则把"str: %s
"都拷贝到dst; 如果size-1小于"str: %s
"的长度,则从"str: %s
"拷贝size-1长度的字符串到dst，并且末尾置 .
就是说，拷贝的长度是size-1和源字符串长度的最小值；
对于返回值，需要注意的是snprintf的返回值是欲写入的字符串（即源字符串）长度，而不是实际写入的字符串度。如：
char test[8];int ret= snprintf(test,5,"1234567890"); printf("%d|%s
",ret,test);
运行结果为：
10|1234
linux和windows下是不同的
linux下用的是snprintf()；
而windows下用的是_snprintf()；
1. 前言
在gcc编程中，我们比较经常用到的字符格式化输出函数是printf的，实际上gcc继承了c语言处理字符具有强大功能的风格，它提供了一系列的格式化输出函数，主要存在两个库函数文件stdio.h/ stdarg.h中，具体函数如下：
NAME
-------- formatted output conver --------
printf, fprintf, dprintf, sprintf, snprintf, vprintf, vfprintf, vdprintf, vsprintf, vsnprintf
sion
SYNOPSIS
#include <stdio.h>
int printf(const char *format, ...);
int fprintf(FILE *stream, const char *format, ...);
int dprintf(int fd, const char *format, ...);
int sprintf(char *str, const char *format, ...);
int snprintf(char *str, size_t size, const char *format, ...);
#include <stdarg.h>
int vprintf(const char *format, va_list ap);
int vfprintf(FILE *stream, const char *format, va_list ap);
int vdprintf(int fd, const char *format, va_list ap);
int vsprintf(char *str, const char *format, va_list ap);
int vsnprintf(char *str, size_t size, const char *format, va_list ap);
其中：
printf和vprintf函数主要是向一个标准输出设备或标准的字符流输出格式化后的字符。
Fprintf和vfprintf 函数主要是向一个给定的字符流设备输出格式化后的字符。
而sprintf, snprintf, vsprintf 和vsnprintf函数则是将格式化后的结果赋值给一个字符串。
虽然函数的功能上有差异，返回的值的类型也不尽相同，但是在建立匹配格式的语法上还是相同的，这几个函数都有一些共同特征，就是你要设计好模板和格式化的字串。这些函数格式化字符串的命令主要是通过模板字符串中跟在“%”后面的字符来控制的。
如下一个例子中：
int pct = 37;
char filename[] = "foo.txt";
printf ("Processing of `%s' is %d%% finished.Please be patient.",filename, pct);
显然，这个例子的打印结果就是如下：
Processing of `foo.txt' is 37% finished.Please be patient.
如上例子我们可以看出一般格式化函数的语法特点就是包含格式化匹配的字符串，输出的字串和变量组合的结构。
2. 参数详细介绍
由于大部分函数在如何格式化字串部分的语法非常相似，我们先研究他们的共同特点，然后再应用不同的例子来分析其不同特点：此类函数一般的调用格式为:printf(";", ;);
其中格式化字符串包括两部分内容: 一部分是正常字符, 这些字符将按原样输出; 另一部分是格式化规定字符, 以"%"开始, 后跟一个或几个规定字符,用来确定输出内容格式。参量表是需要输出的一系列参数, 其个数必须与格式化字符串所说明的输出参数个数一样多, 各参数之间用","分开, 且顺序一一对应, 否则将会出现意想不到的错误。
Gcc提供的格式化规定符如下:
%d 十进制有符号整数
%i 十进制有符号整数
注:上面这两个函数在格式化输出时用途是相同的，但在输入时却是不一样的，
%i可以接受任何形式的整数，而%d却不能。
%u 十进制无符号整数
%f 输出浮点数
%s 输出字符串
%c 输出单个字符
%p 输出指针的值
%e, %E 指数形式的浮点数 ,其中:%e是以小写形式输出的 %E是以大写形式输出的
%x, %X 无符号以十六进制表示的整数，其中:%x是以小写形式输出的 %X是以大写形式输出的
%g, %G 根据输出数据的大小需要决定用普通形式还是指数形式的输出方式，
其中: %g是以小写形式输出的 %G是以大写形式输出的
%o 无符号以八进制表示的整数
%c 输出单个字符
%n 得到输出字符的个数，但是本参数不产生任何的输出效果。
%m 输出错误时的相应的字符串提示。
%% 输出正文字符中的“%”字符
说明: 可以在"%"和字母之间插进数字表示最大场宽。例如: %3d 表示输出3位整型数, 不够3位右对齐。%9.2f 表示输出场宽为9的浮点数, 其中小数位为2, 整数位为6,小数点占一位, 不够9位右对齐。%8s 表示输出8个字符的字符串, 不够8个字符右对齐。如果字符串的长度、或整型数位数超过说明的场宽, 将按其实际长度输出。但对浮点数, 若整数部分位数超过了说明的整数位宽度, 将按实际整数位输出;若小数部分位数超过了说明的小数位宽度, 则按说明的宽度以四舍五入输出。另外, 若想在输出值前加一些0, 就应在场宽项前加个0。例如: %04d 表示在输出一个小于4位的数值时, 将在前面补0使其总宽度为4位。如果用浮点数表示字符或整型量的输出格式, 小数点后的数字代表最大宽度,小数点前的数字代表最小宽度。
例如: %6.9s 表示显示一个长度不小于6且不大于9的字符串。若大于9, 则第9个字符以后的内容将被删除。
可以在"%"和字母之间加小写字母l, 表示输出的是长型数。
例如: %ld 表示输出long整数%lf 表示输出double浮点数
可以控制输出左对齐或右对齐, 即在"%"和字母之间加入一个"-" 号可
说明输出为左对齐, 否则为右对齐。例如: %-7d 表示输出7位整数左对齐%-10s表示输出10个字符左对齐
一些特殊规定字符
3. 格式化转换的具体细则
3.1 整数转换部分
整数转换部分主要是'%d', '%i', '%o', '%u', '%x', 和 '%X'这几个参数命令的，由于参数的不同，可以输出不同格式的结果。如上表所列： '%d', '%i'是输出一个带符号的十进制的数，'%o', '%u', and '%x'是输出一个不带符号的数，而'%X是'%x''的大写形式。其中，针对这几种不同输出选择还有如下几个参数项：
'-’ 表示是左对齐，一般都是右对齐的。
'+’ 是对'%d', '%i'两个参数而言的，是指以'+’符号表示正数
' ' 是对'%d', '%i'两个参数而言的,如果输出不是以'+’'-’开头的，那么用空格做开头。
'#' 是对'%o'参数而言的，将在输出的结果强制加上'0’为开头。
''' 将输出的数字以LC_NUMERIC的分类法用’,’隔开。
'0' 将空格的地方用'0'填入。
如果没有特别指明，被格式化的参数被默认当作整数处理，或者可以用以下的类型指定参数来进行修改，如下：
'h' 指定传入参数是 short int 或unsigned short int类型的
'l' 指定传入参数是 long int或unsigned long int类型的
'q' 指定传入参数是 long long int类型的
'Z' 指定传入参数是size_t.。
为了方便理解给出一个例子：
对于如下的格式化匹配字串：
"|%5d|%-5d|%+5d|%+-5d|% 5d|%05d|%5.0d|%5.2d|%d|"
将产生类似如下的输出：
| 0|0 | +0|+0 | 0|00000| | 00|0|
| 1|1 | +1|+1 | 1|00001| 1| 01|1|
| -1|-1 | -1|-1 | -1|-0001| -1| -01|-1|
|100000|100000|+100000| 100000|100000|100000|100000|100000|
对于如下的格式化匹配字串：
"|%5u|%5o|%5x|%5X|%#5o|%#5x|%#5X|%#10.8x|"
将产生类似如下的输出：
| 0| 0| 0| 0| 0| 0x0| 0X0|0x00000000|
| 1| 1| 1| 1| 01| 0x1| 0X1|0x00000001|
|100000|303240|186a0|186A0|0303240|0x186a0|0X186A0|0x000186a0|
3.2 浮点数的转换部分
浮点数转换部分主要是'%f', '%e', '%E', '%g', 和 '%G' '这几个参数命令的，由于参数的不同，可以输出不同格式的结果。如上表所列： '%f'是输出一个比较固定形式的浮点数……其中，针对这几种不同输出选择还有如下几个参数项：
'-’ 表示是左对齐，一般都是右对齐的。
'+’ 是指以'+’符号表示正数
' ' 如果输出不是以'+’'-’开头的，那么用空格做开头
'#' 是对'%g'和'%G’参数而言的，将在输出的结果强制加上'0’为开头。
''' 将输出的数字以LC_NUMERIC的分类法用’,’隔开。
'0' 将空格的地方用“0'填入。
如果没有特别指定，传入的被格式化的参数默认是double类型的，可以用'L’表示是一个long double类型的。
如下例子可以看出浮点数格式化的字串：
如下的格式字串：
"|%12.4f|%12.4e|%12.4g|"
可能产生如下的输出：
| 0.0000| 0.0000e+00| 0|
| 1.0000| 1.0000e+00| 1|
| -1.0000| -1.0000e+00| -1|
| 100.0000| 1.0000e+02| 100|
| 1000.0000| 1.0000e+03| 1000|
| 10000.0000| 1.0000e+04| 1e+04|
| 12345.0000| 1.2345e+04| 1.234e+04|
| 100000.0000| 1.0000e+05| 1e+05|
| 123456.0000| 1.2346e+05| 1.234e+05|
3.3 其他格式的转换部分
这部分的函数比较简单一些，具体如下：
'%c’是指输出一个单个的字符串，默认的输出的被格式化的参数是unsigned char类型的，可以用'-’表示左对齐的。没有的别的参数，比如:
printf ("%c%c%c%c%c", 'h', 'e', 'l', 'l', 'o');
显示结果为： 'hello'
'%s’是输出一个字串，. 默认的输出的被格式化的参数是char * (or const char *). 类型的，可以用'-’表示左对齐的。没有的别的参数，比如：
printf ("%3s%-6s", "no", "where");
显示结果： ' nowhere '.
注： 如果你用这个参数来格式化输出一个指针类型的参数时，有可能会得到一个'(null)'的输出值。不过有时候用于指针为空的缘故程序运行时会产生“Segmentation fault”的错误，下面一个例子就会产生这样的错误：
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
void main()
{
char a;
a = inet_addr("192.168.1.1");
if(a!=-1)
{
printf("ip:%s",a);/* 这里的%s可能会产生错误，应改用用%p比较好一些*/
}
}
'%m’是输出error信息的。如下例子：
fprintf (stderr, "can't open '%s': %m", filename);
等于如下的输出命令：
fprintf (stderr, "can't open '%s': %s", filename, strerror (errno));
“%p”是输出指针类型参数的，显然被格式化的输入蚕室必须是指针，可以用“－”来表示左对齐的。
“%n”是比较特殊的参数，它不对格式化输出影响，而是得到输出结果的字符长度，可以用类型指定参数'h' 和 'l'来分别指定输出的参数分别是short int *和 long int *类型的。如下面的例子：
int nchar;
printf ("%d %s%n", 3, "bears", &nchar);
输出结果：
3 bears
同时将7的值赋给变量nchar。
'%%'是输出“％”的字符。
4. 函数具体介绍
4.1printf()函数
printf()函数是格式化输出函数系列中比较有具有普遍特点的, 一般用于向标准输出设备按规定格式输出信息。在编写程序时经常会用到此函数。printf()函数的调用格式为：printf(";", ;);
#include <stdio.h>
#include <stdlib.h>
int main()
{
char c, s[20], *p;
int a=1234, *i;
float f=3.141592653589;
double x=0.12345678987654321;
p = "How do you do";
strcpy(s, "Hello, Comrade");
*i=12;
c='x41';
printf("a=%d", a); /* 结果输出十进制整数a=1234 */
printf("a=%6d", a); /* 结果输出6位十进制数a= 1234 */
printf("a=%06d", a); /* 结果输出6位十进制数a=001234 */
printf("a=%2d", a); /* a超过2位, 按实际值输出a=1234 */
printf("*i=%4d", *i); /* 输出4位十进制整数*i= 12 */
printf("*i=%-4d", *i); /* 输出左对齐4位十进制整数*i=12 */
printf("i=%p", i); /* 输出地址i=06E4 */
printf("f=%f", f); /* 输出浮点数f=3.141593 */
printf("f=6.4f", f); /* 输出6位其中小数点后4位的浮点数f=3.1416 */
printf("x=%lf", x); /* 输出长浮点数x=0.123457 */
printf("x=%18.16lf", x); /* 输出18位其中小数点后16位的长浮点数x=0.1234567898765432 */
printf("c=%c", c); /* 输出字符c=A */
printf("c=%x", c); /* 输出字符的ASCII码值c=41 */
printf("s[]=%s", s); /* 输出数组字符串s[]=Hello, Comrade */
printf("s[]=%6.9s", s); /* 输出最多9个字符的字符串s[]=Hello,Co */
printf("s=%p", s); /* 输出数组字符串首字符地址s=FFBE */
printf("*p=%s", p); /* 输出指针字符串p=How do you do */
printf("p=%p", p); /* 输出指针的值p=0194 */
getch();
retunr 0;
}
上面结果中的地址值在不同计算机上可能不同。
例子中第一条语句#include的含义是调用另一个文件stdio.h, 这是一个头文件, 其中包括全部标准输入输出库函数的数据类型定
义和函数说明。对每个库函数便用的变量及函数类型都已作了定义与说明, 放在相应头文件"*.h"中, 用户用到这些函数时必须要
用#include;或#include"*.h" 语句调用相应的头文件, 以供若没有用此语句说明, 则连接时将会出现错误。
4.2 fprintf()函数
fprintf( ) 函数中格式化的规定与printf( ) 函数相同, 所不同的只是fprintf()函数是向文件中写入。而printf()是向屏幕输出。
下面介绍一个例子, 运行后产后一个test.dat的文件。
#include <stdio.h>
#include <stdlib.h>
void main()
{
char *s="That's good news"}; /*定义字符串指针并初始化*/
int i=617; /*定义整型变量并初始化*/
FILE *fp; /*定义文件指针*/
fp=fopne("test.dat", "w"); /*建立一个文字文件只写*/
fputs("Your score of TOEFLis", fp); /*向所建文件写入一串字符*/
fputc(':', fp); /*向所建文件写冒号:*/
fprintf(fp, "%d", i); /*向所建文件写一整型数*/
fprintf(fp, "%s", s); /*向所建文件写一字符串*/
fclose(fp); /*关闭文件*/
}
用CAT命令显示TEST.DAT的内容如下所示:屏幕显示
Your score of TOEFL is: 617
That's good news
4.3 sprintf() 函数
sprintf(string, fmt, ...)传回的是string的类型的数组，并以空字符结尾。不过，该函数有可能超过为字符分配的长度。比较危险。下面是一个sprintf()的事例。
//根据传进来的Mission数据结构，建立socket链接，取得文件的大小。
int get_size_of_url(struct Mission* pms)
{
int s;
struct sockaddr_in sin;
struct hostent* phe;
char cmd[256];
char msg_hdr[1000];
char* p;
//准备http中GET 方法的请求。
sprintf(cmd,"GET %s HTTP/1.0", pms->;url);
//创建socket
if((s=socket(PF_INET,SOCK_STREAM,0))<0) return -1;
//取得远程主机的IP地址，失败函数返回－1
if((phe = gethostbyname(pms->;host)) == NULL) return -1;
memset(&sin,0,sizeof(sin));
memcpy(&sin.sin_addr,phe->h_addr,sizeof(struct in_addr));
sin.sin_family=AF_INET;
sin.sin_port=htons(pms->;port);
//跟远程机器建立连接，失败函数返回－1
if(connect(s,(struct sockaddr*)&sin,sizeof(sin))==-1) return -1;
//发送GET请求
if(write(s,cmd,strlen(cmd))<0) return 0;
//从链接描述符（连接管道）中读取传送过来的数据
if(read(s, msg_hdr, 300)<0) return 0;
close(s);
printf("%s",msg_hdr);
//读到该文件的大小
if((p=strstr(msg_hdr,"Content-Length"))||(p=strstr(msg_hdr,"Content-length:"))) p+=16;
else return 0;
//返回大小
return atoi(p))
｝
注：在大部份的Unix系统上，sprintf(string, fmt, ...)传回的是string的指标，然而，这方面Linux（遵循ANSI）传回的却是放入string内的字元数目.进行移植时，尤其是针对SunOS，需有警觉的心。
4.4 Snprintf()函数
Snprintf()函数与Sprintf()函数极为相似，但是该函数多了size参数来表示最大的字符数目，该函数返回一个整数值表示被存储的字符的数目，如果返回－1则表示输出的字符空间不够。如下例子：
char *make_message (char *name, char *value)
{
/* 预分配100个字符空间. */
int size = 100;
char *buffer = (char *) xmalloc (size);
while (1)
{
/* 输出格式化的字符到给定的空间中. */
int nchars = snprintf (buffer, size,"value of %s is %s",name, value);
/* 判断是否返回真值 */
if (nchars < size) return buffer;
/* 如果空间不够，加大预分配空间到2倍 */
size *= 2;
buffer = (char *) xrealloc (size, buffer);
}
}
4.5 asprintf()函数
int asprintf (char **ptr, const char *template, ...)
本函数跟sprintf()函数很类似，只是它将字符串的分配改成动态分配的形式，参数ptr是指一个char *对象的地址函数返回指向一个新建的指针。如下例子：
/* Construct a message describing the value of a variable whose name is name and whose value is value. */
char *make_message (char *name, char *value)
{
char *result;
asprintf (&result, "value of %s is %s", name, value);
return result;
}
4.6 Vprintf()函数
int vprintf (const char *template, va_list ap)
本函数跟printf函数很类似，只是将参数的数目可变的，变成了一个指针的列表。
4.7 Vfprintf()函数
int vfprintf (FILE *stream, const char *template, va_list ap)
本函数跟fprintf函数很类似，只是将参数的数目可变的，变成了一个指针的列表。
4.8 vfprintf()函数
int vsprintf (char *s, const char *template, va_list ap)
本函数跟sprintf函数很类似，只是将参数的数目可变的，变成了一个指针的列表。
4.9 vsnprintf()函数
int vsnprintf (char *s, size_t size, const char *template, va_list ap)
本函数跟snprintf函数很类似，只是将参数的数目可变的，变成了一个指针的列表。
4.10 vasprintf()函数
int vasprintf (char **ptr, const char *template, va_list ap)
本函数跟asprintf函数很类似，只是将参数的数目可变的，变成了一个指针的列表。
字符串格式化函数 sprintf 和 printf
在将各种类型的数据构造成字符串时，sprintf 的强大功能很少会让你失望。由于sprintf 跟 printf 在用法上几乎一样，只是打印的目的地不同而已，sprintf 打印到字符串中，printf 则直接在命令行上输出。这也导致sprintf 比printf 有用得多。
sprintf 是个变参函数，定义如下：
int sprintf( char *buffer, const char *format [, argument] ... );除了前两个参数类型固定外，后面可以接任意多个参数。而它的精华，显然就在第二个参数：格式化字符串上。
printf 和sprintf 都使用格式化字符串来指定串的格式，在格式串内部使用一些以"%"开头的格式说明符（format specifications）来占据一个位置，在后边的变参列表中提供相应的变量，最终函数就会用相应位置的变量来替代那个说明符，产生一个调用者想要 的字符串。
1. 格式化数字字符串
sprintf 最常见的应用之一莫过于把整数打印到字符串中，所以，spritnf 在大多数场合可以替代itoa。如：
//把整数123 打印成一个字符串保存在s 中。
sprintf(s, "%d", 123); //产生"123"可以指定宽度，不足的左边补空格：
sprintf(s, "%8d%8d", 123, 4567); //产生：" 123 4567"当然也可以左对齐：
sprintf(s, "%-8d%8d", 123, 4567); //产生："123 4567"
也可以按照16 进制打印：
sprintf(s, "%8x", 4567); //小写16 进制，宽度占8 个位置，右对齐
sprintf(s, "%-8X", 4568); //大写16 进制，宽度占8 个位置，左对齐
这样，一个整数的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);
sprintf 和printf 还可以按8 进制打印整数字符串，使用"%o"。注意8 进制和16 进制都不会打
印出负数，都是无符号的，实际上也就是变量的内部编码的直接的16 进制或8 进制表示。
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. 字符
在C/C++语言中，char 也是一种普通的scalable 类型，除了字长之外，它与short，int，long 这些类型没有本质区别，只不过被大家习惯用来表示字符和字符串而已。（或许当年该把这 个类型叫做"byte"，然后现在就可以根据实际情况，使用byte 或short 来把char 通过typedef 定义出来，这样更合适些）于是，使用"%d"或者"%x"打印一个字符，便能得出它的10 进制或16 进制的ASCII 码；反过来，使用"%c"打印一个整数，便可以看到它所对应的ASCII 字符。以下程序段把所有可见字符的ASCII 码对照表打印到屏幕上（这里采用printf，注意"#"与"%X"合用时自动为16 进制数增加"0X"前缀）：
for(int i = 32; i < 127; i++)
{
printf("[ %c ]: %3d 0x%#04X
", i, i, i);
}
4. 连接字符串
sprintf 的格式控制串中既然可以插入各种东西，并最终把它们"连成一串"，自然也就能够连接字符串，从而在许多场合可以替代strcat，但sprintf 能够一次连接多个字符串（自然也可以同时在它们中间插入别的内容，总之非常灵活）。比如：
char* who = "I";
char* whom = "CSDN";
sprintf(s, "%s love %s.", who, whom); //产生："I love CSDN. "
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 的实现中也被考虑到了，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"
5. 打印地址信息
有时调试程序时，我们可能想查看某些变量或者成员的地址，由于地址或者指针也不过是个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);
利用sprintf 的返回值
较少有人注意printf/sprintf 函数的返回值，但有时它却是有用的，spritnf 返回了本次函数调用最终打印到字符缓冲区中的字符数目。也就是说每当一次sprinf 调用结束以后，你无须再调用一次strlen 便已经知道了结果字符串的长度。如：int len = sprintf(s, "%d", i);对于正整数来说，len 便等于整数i 的10 进制位数。下面的是个完整的例子，产生10 个[0, 100)之间的随机数，并将他们打印到一个字符数组s 中，以逗号分隔开。
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main()
{
srand(time(0));
char s[64];
int offset = 0;
for(int i = 0; i < 10; i++) {
offset += sprintf(s + offset, "%d,", rand() % 100);
}
s[offset - 1] = '
';//将最后一个逗号换成换行符。
printf(s);
return 0;
}
设想当你从数据库中取出一条记录，然后希望把他们的各个字段按照某种规则连接成一个字符串时，就可以使用这种方法，从理论上讲，他应该比不断的 strcat 效率高，因为strcat 每次调用都需要先找到最后的那个''的位置，而在上面给出的例子中，我们每次都利用sprintf 返回值把这个位置直接记下来了。
6. 使用
sprintf 的常见问题
sprintf 是个变参函数，使用时经常出问题，而且只要出问题通常就是能导致程序崩溃的内存访问错误，但好在由sprintf 误用导致的问题虽然严重，却很容易找出，无非就是那么几种情况，通常用眼睛再把出错的代码多看几眼就看出来了。
1. 缓冲区溢出。第一个参数的长度太短了，没的说，给个大点的地方吧。当然也可能是后面的参数的问题，建议变参对应一定要细心，而打印字符串时，尽量使用"%.ns"的形式指定最大字符数。
2. 忘记了第一个参数低级得不能再低级问题，用printf 用得太惯了。//偶就常犯。
3. 变参对应出问题。通常是忘记了提供对应某个格式符的变参，导致以后的参数统统错位，检查检查吧。尤其是对应"*"的那些参数，都提供了吗？不要把一个整数对应一个"%s"，编译器会觉得你欺她太甚了（编译器是obj 和exe 的妈妈，应该是个女的，:P）。
http://blog.chinaunix.net/uid-12555930-id-2929695.html
ChinaUnix首页 > 精华文章 > C/C++ > 正文
[精华] gcc中格式化输出函数的研究（转）
By 书生
<一>;
1.前言
在gcc编程中，我们比较经常用到的字符格式化输出函数是printf的，实际上gcc继承了c语言处理字符具有强大功能的风格，它提供了一系列的格式化输出函数，主要存在两个库函数文件stdio.h/ stdarg.h中，具体函数如下：
include
printf, int printf(const char *format, ...);
fprintf, int fprintf(FILE *stream, const char *format, ...);
sprintf, int sprintf(char *str, const char *format, ...);
snprintf, int snprintf(char *str, size_t size, const char *format, ...);
include
vprintf, vprintf(const char *format, va_list ap);
vfprintf, vfprintf(FILE *stream, const char *format, va_list ap);
vsprintf, int vsprintf(char *str, const char *format, va_list ap);
其中：
printf和vprintf函数主要是向一个标准输出设备或标准的字符流输出格式化后的字符。
Fprintf和vfprintf 函数主要是向一个给定的字符流设备输出格式化后的字符。
而sprintf, snprintf, vsprintf 和vsnprintf函数则是将格式化后的结果赋值给一个字符串。
虽然函数的功能上有差异，返回的值的类型也不尽相同，但是在建立匹配格式的语法上还是相同的，这几个函数都有一些共同特征，就是你要设计好模板和格式化的字串。这些函数格式化字符串的命令主要是通过模板字符串中跟在“%”后面的字符来控制的。
如下一个例子中：
int pct = 37;
char filename[] = "foo.txt";
printf ("Processing of `%s' is %d%% finished.Please be patient.",filename, pct);
显然，这个例子的打印结果就是如下：
Processing of `foo.txt' is 37% finished.Please be patient.
如上例子我们可以看出一般格式化函数的语法特点就是包含格式化匹配的字符串，输出的字串和变量组合的结构。
2.参数详细介绍
由于大部分函数在如何格式化字串部分的语法非常相似，我们先研究他们的共同特点，然后再应用不同的例子来分析其不同特点：此类函数一般的调用格式为:printf("<格式化字符串>;", <参量表>;);
其中格式化字符串包括两部分内容: 一部分是正常字符, 这些字符将按原样输出; 另一部分是格式化规定字符, 以"%"开始, 后跟一个或 几个规定字符,用来确定输出内容格式。参量表是需要输出的一系列参数, 其个数必须与格式化字符串所说明的输出参数个数一样多, 各参数之间用","分 开, 且顺序一一对应, 否则将会出现意想不到的错误。
2.1 Gcc提供的格式化规定符如下:
%d
十进制有符号整数
%i
十进制有符号整数
注:上面这两个函数在格式化输出时用途是相同的，但在输入时却是不一样的，%i可以接受任何形式的整数，而%d却不能。
%u
十进制无符号整数
%f
输出浮点数
%s
输出字符串
%c
输出单个字符
%p
输出指针的值
%e %E
指数形式的浮点数 ,其中:%e是以小写形式输出的 %E是以大写形式输出的
%x, %X
无符号以十六进制表示的整数，其中:%x是以小写形式输出的 %X是以大写形式输出的
%g', %G'
根据输出数据的大小需要决定用普通形式还是指数形式的输出方式，其中: %g是以小写形式输出的 %G是以大写形式输出的
%o
无符号以八进制表示的整数
`%c
'输出单个字符
%n
得到输出字符的个数，但是本参数不产生任何的输出效果。
`%m'
输出错误时的相应的字符串提示。
`%%'
输出正文字符中的“%”字符
说明:
可以在"%"和字母之间插进数字表示最大场宽。例如: %3d 表示输出3位整型数, 不够3位右对齐。%9.2f 表示输出场宽为9的浮点 数, 其中小数位为2, 整数位为6,小数点占一位, 不够9位右对齐。%8s 表示输出8个字符的字符串, 不够8个字符右对齐。如果字符串的长度、或 整型数位数超过说明的场宽, 将按其实际长度输出。但对浮点数, 若整数部分位数超过了说明的整数位宽度, 将按实际整数位输出;若小数部分位数超过了说 明的小数位宽度, 则按说明的宽度以四舍五入输出。另外, 若想在输出值前加一些0, 就应在场宽项前加个0。例如: %04d 表示在输出一个小于4位 的数值时, 将在前面补0使其总宽度为4位。如果用浮点数表示字符或整型量的输出格式, 小数点后的数字代表最大宽度,小数点前的数字代表最小宽度。
例如: %6.9s 表示显示一个长度不小于6且不大于9的字符串。若大于9, 则第9个字符以后的内容将被删除。
可以在"%"和字母之间加小写字母l, 表示输出的是长型数。
例如: %ld 表示输出long整数%lf 表示输出double浮点数
可以控制输出左对齐或右对齐, 即在"%"和字母之间加入一个"-" 号可
说明输出为左对齐, 否则为右对齐。例如: %-7d 表示输出7位整数左对齐%-10s表示输出10个字符左对齐
2.2 一些特殊规定字符
换行
f 清屏并换页
回车
Tab符
xhh 表示一个ASCII码用16进表示,其中hh是1到2个16进制数
HopeCao 回复于：2003-02-28 13:14:31
<二>;
3.格式化转换的具体细则
3.1 整数转换部分
整数转换部分主要是'%d', '%i', '%o', '%u', '%x', 和 '%X'这几个参数命令的，由于参数的不同，可以输出 不同格式的结果。如上表所列： '%d', '%i'是输出一个带符号的十进制的数，'%o', '%u', and '%x'是输出一个不带符号的数， 而'%X是'%x''的大写形式。其中，针对这几种不同输出选择还有如下几个参数项：
'-’ 表示是左对齐，一般都是右对齐的。
'+’ 是对'%d', '%i'两个参数而言的，是指以'+’符号表示正数
' ' 是对'%d', '%i'两个参数而言的,如果输出不是以'+’'-’开头的，那么用空格做开头。
'#' 是对'%o'参数而言的，将在输出的结果强制加上'0’为开头。
''' 将输出的数字以LC_NUMERIC的分类法用’,’隔开。
'0' 将空格的地方用'0'填入。
如果没有特别指明，被格式化的参数被默认当作整数处理，或者可以用以下的类型指定参数来进行修改，如下：
'h' 指定传入参数是 short int 或unsigned short int类型的
'l' 指定传入参数是 long int或unsigned long int类型的
'q' 指定传入参数是 long long int类型的
'Z' 指定传入参数是size_t.。
为了方便理解给出一个例子：
对于如下的格式化匹配字串：
"|%5d|%-5d|%+5d|%+-5d|% 5d|%05d|%5.0d|%5.2d|%d|"
将产生类似如下的输出：
| 0|0 | +0|+0 | 0|00000| | 00|0|
| 1|1 | +1|+1 | 1|00001| 1| 01|1|
| -1|-1 | -1|-1 | -1|-0001| -1| -01|-1|
|100000|100000|+100000| 100000|100000|100000|100000|100000|
对于如下的格式化匹配字串：
"|%5u|%5o|%5x|%5X|%#5o|%#5x|%#5X|%#10.8x|"
将产生类似如下的输出：
| 0| 0| 0| 0| 0| 0x0| 0X0|0x00000000|
| 1| 1| 1| 1| 01| 0x1| 0X1|0x00000001|
|100000|303240|186a0|186A0|0303240|0x186a0|0X186A0|0x000186a0|
3.2 浮点数的转换部分
浮点数转换部分主要是'%f', '%e', '%E', '%g', 和 '%G' '这几个参数命令的，由于参数的不同，可以输出不同格式的结果。如上表所列： '%f'是输出一个比较固定形式的浮点数……其中，针对这几种不同输出选择还有如下几个参数项：
'-’ 表示是左对齐，一般都是右对齐的。
'+’ 是指以'+’符号表示正数
' ' 如果输出不是以'+’'-’开头的，那么用空格做开头
'#' 是对'%g'和'%G’参数而言的，将在输出的结果强制加上'0’为开头。
''' 将输出的数字以LC_NUMERIC的分类法用’,’隔开。
'0' 将空格的地方用“0'填入。
如果没有特别指定，传入的被格式化的参数默认是double类型的，可以用'L’表示是一个long double类型的。
如下例子可以看出浮点数格式化的字串：
如下的格式字串：
"|%12.4f|%12.4e|%12.4g|"
可能产生如下的输出：
| 0.0000| 0.0000e+00| 0|
| 1.0000| 1.0000e+00| 1|
| -1.0000| -1.0000e+00| -1|
| 100.0000| 1.0000e+02| 100|
| 1000.0000| 1.0000e+03| 1000|
| 10000.0000| 1.0000e+04| 1e+04|
| 12345.0000| 1.2345e+04| 1.234e+04|
| 100000.0000| 1.0000e+05| 1e+05|
| 123456.0000| 1.2346e+05| 1.234e+05|
3.3 其他格式的转换部分
这部分的函数比较简单一些，具体如下：
'%c’是指输出一个单个的字符串，默认的输出的被格式化的参数是unsigned char类型的，可以用'-’表示左对齐的。没有的别的参数，比如:
printf ("%c%c%c%c%c", 'h', 'e', 'l', 'l', 'o');
显示结果为： 'hello'
'%s’是输出一个字串，. 默认的输出的被格式化的参数是char * (or const char *). 类型的，可以用'-’表示左对齐的。没有的别的参数，比如：
printf ("%3s%-6s", "no", "where");
显示结果： ' nowhere '.
注： 如果你用这个参数来格式化输出一个指针类型的参数时，有可能会得到一个'(null)'的输出值。不过有时候用于指针为空的缘故程序运行时会产生“Segmentation fault”的错误，下面一个例子就会产生这样的错误：
include
main()
{
char a;
a = inet_addr("192.168.1.1");
if(a!=-1){
printf("ip:%s",a);/* 这里的%s可能会产生错误，应改用用%p比较好一些*/
}
}
'%m’是输出error信息的。如下例子：
fprintf (stderr, "can't open '%s': %m", filename);
等于如下的输出命令：
fprintf (stderr, "can't open '%s': %s", filename, strerror (errno));
“%p”是输出指针类型参数的，显然被格式化的输入蚕室必须是指针，可以用“－”来表示左对齐的。
“%n”是比较特殊的参数，它不对格式化输出影响，而是得到输出结果的字符长度，可以用类型指定参数'h' 和 'l'来分别指定输出的参数分别是short int *和 long int *类型的。如下面的例子：
int nchar;
printf ("%d %s%n", 3, "bears", &nchar);
输出结果：
3 bears
同时将7的值赋给变量nchar。
'%%'是输出“％”的字符。
HopeCao 回复于：2003-02-28 13:19:11
<三>;
4.函数具体介绍
4.1printf()函数
printf()函数是格式化输出函数系列中比较有具有普遍特点的, 一般用于向标准输出设备按规定格式输出信息。在编写程序时经常会用到此函数。printf()函数的调用格式为:
printf("<格式化字符串>;", <参量表>;);
include
include
int main()
{
char c, s[20], *p;
int a=1234, *i;
float f=3.141592653589;
double x=0.12345678987654321;
p="How do you do";
strcpy(s, "Hello, Comrade");
*i=12;
c='x41';
printf("a=%d", a); /结果输出十进制整数a=1234/
printf("a=%6d", a); /结果输出6位十进制数a= 1234/
printf("a=%06d", a); /结果输出6位十进制数a=001234/
printf("a=%2d", a); /a超过2位, 按实际值输出a=1234/
printf("i=%4d", i); /输出4位十进制整数i= 12*/
printf("i=%-4d", i); /输出左对齐4位十进制整数i=12*/
printf("i=%p", i); /输出地址i=06E4/
printf("f=%f", f); /输出浮点数f=3.141593/
printf("f=6.4f", f); /输出6位其中小数点后4位的浮点数f=3.1416/
printf("x=%lf", x); /输出长浮点数x=0.123457/
printf("x=%18.16lf", x);/输出18位其中小数点后16位的长浮点数x=0.1234567898765432/
printf("c=%c", c); /输出字符c=A/
printf("c=%x", c); /输出字符的ASCII码值c=41/
printf("s[]=%s", s); /输出数组字符串s[]=Hello, Comrade/
printf("s[]=%6.9s", s);/输出最多9个字符的字符串s[]=Hello,Co/
printf("s=%p", s); /输出数组字符串首字符地址s=FFBE/
printf("p=%s", p); / 输出指针字符串p=How do you do*/
printf("p=%p", p); /输出指针的值p=0194/
getch();
retunr 0;
}
上面结果中的地址值在不同计算机上可能不同。
例子中第一条语句#include的含义是调用另一个文件stdio.h, 这是一个头文件, 其中包括全部标准输入输出库函数的数据类型定 义和函数说明。对每个库函数便用的变量及函数类型都已作了定义与说明, 放在相应头文件".h"中, 用户用到这些函数时必须要 用#include<.h>;或#include"*.h" 语句调用相应的头文件, 以供若没有用此语句说明, 则连接时将会出现错误。
4.2 fprintf()函数
fprintf( ) 函数中格式化的规定与printf( ) 函数相同, 所不同的只是fprintf()函数是向文件中写入。而printf()是向屏幕输出。
下面介绍一个例子, 运行后产后一个test.dat的文件。
include
main()
{
char s="That's good news"}; /定义字符串指针并初始化*/
int i=617; /定义整型变量并初始化/
FILE fp; /定义文件指针*/
fp=fopne("test.dat", "w"); /建立一个文字文件只写/
fputs("Your score of TOEFLis", fp);/向所建文件写入一串字符/
fputc(':', fp); /向所建文件写冒号:/
fprintf(fp, "%d", i); /向所建文件写一整型数/
fprintf(fp, "%s", s); /向所建文件写一字符串/
fclose(fp); /关闭文件/
}
用CAT命令显示TEST.DAT的内容如下所示:屏幕显示
Your score of TOEFL is: 617
That's good news
4.3 sprintf() 函数
sprintf(string, fmt, ...)传回的是string的类型的数组，并以空字符结尾。不过，该函数有可能超过为字符分配的长度。比较危险。下面是一个sprintf()的事例。
int
//根据传进来的Mission数据结构，建立socket链接，取得文件的大小。
get_size_of_url(struct Mission* pms)
{
int s;
struct sockaddr_in sin;
struct hostent* phe;
char cmd[256];
char msg_hdr[1000];
char* p;
//准备http中GET 方法的请求。
sprintf(cmd,"GET %s HTTP/1.0", pms->;url);
//创建socket
if((s=socket(PF_INET,SOCK_STREAM,0))<0)
return -1;
//取得远程主机的IP地址，失败函数返回－1
if((phe = gethostbyname(pms->;host)) == NULL)
return -1;
memset(&sin,0,sizeof(sin));
memcpy(&sin.sin_addr,phe->;h_addr,sizeof(struct in_addr));
sin.sin_family=AF_INET;
sin.sin_port=htons(pms->;port);
//跟远程机器建立连接，失败函数返回－1
if(connect(s,(struct sockaddr*)&sin,sizeof(sin))==-1)
return -1;
//发送GET请求
if(write(s,cmd,strlen(cmd))<0)
return 0;
//从链接描述符（连接管道）中读取传送过来的数据
if(read(s, msg_hdr, 300)<0)
return 0;
close(s);
printf("%s",msg_hdr);
//读到该文件的大小
if((p=strstr(msg_hdr,"Content-Length"))||(p=strstr(msg_hdr,"Content-length:")))
p+=16;
else
return 0;
//返回大小
return atoi(p);
}
注：在大部份的Unix系统上，sprintf(string, fmt, ...)传回的是string的指标，然而，这方面Linux（遵循ANSI）传回的却是放入string内的字元数目.进行移植时，尤其是针对SunOS，需有警觉的心。
4.4 Snprintf()函数
Snprintf()函数与Sprintf()函数极为相似，但是该函数多了size参数来表示最大的字符数目，该函数返回一个整数值表示被存储的字符的数目，如果返回－1则表示输出的字符空间不够。如下例子：
char *
make_message (char *name, char *value)
{
/* 预分配100个字符空间. */
int size = 100;
char *buffer = (char *) xmalloc (size);
while (1)
{
/* 输出格式化的字符到给定的空间中. */
int nchars = snprintf (buffer, size,"value of %s is %s",name, value);
/* 判断是否返回真值 */
if (nchars < size)
return buffer;
/* 如果空间不够，加大预分配空间到2倍 */
size *= 2;
buffer = (char *) xrealloc (size, buffer);
}
}
4.5 asprintf()函数
int asprintf (char **ptr, const char *template, ...)
本函数跟sprintf()函数很类似，只是它将字符串的分配改成动态分配的形式，参数ptr是指一个char *对象的地址函数返回指向一个新建的指针。如下例子：
/* Construct a message describing the value of a variable whose name is name and whose value is value. */
char *
make_message (char *name, char *value)
{
char *result;
asprintf (&result, "value of %s is %s", name, value);
return result;
}
4.6 Vprintf()函数
int vprintf (const char *template, va_list ap)
本函数跟printf函数很类似，只是将参数的数目可变的，变成了一个指针的列表。
4.7 Vfprintf()函数
int vfprintf (FILE *stream, const char *template, va_list ap)
本函数跟fprintf函数很类似，只是将参数的数目可变的，变成了一个指针的列表。
4.8 vfprintf()函数
int vsprintf (char *s, const char *template, va_list ap)
本函数跟sprintf函数很类似，只是将参数的数目可变的，变成了一个指针的列表。
4.9 vsnprintf()函数
int vsnprintf (char *s, size_t size, const char *template, va_list ap)
本函数跟snprintf函数很类似，只是将参数的数目可变的，变成了一个指针的列表。
4.10 vasprintf()函数
int vasprintf (char **ptr, const char *template, va_list ap)
本函数跟asprintf函数很类似，只是将参数的数目可变的，变成了一个指针的列表。
无双 回复于：2003-03-28 12:52:50
UP一下
HopeCao 回复于：2003-03-28 13:12:07
讲得确实是很全，好多我们平时都没有注意！！！