go语言 strconv Atoi Itoa 例子
0人收藏此代码,
golang strconv atoi itoa 在做任何项目的时候都要用到字符串和数字,相互转换是最近基本的操作,哈哈 这里就介绍golang怎么做这些事情
参考代码如下:
package main
func main() {
i, err := strconv.Atoi(&12345&)
if err != nil {
panic(err)
println(i)
s := strconv.Itoa(12345)
println(s)
//该代码片段来自于: http://www.sharejs.com/codes/go/4383
相关代码片段:
最新Go语言代码片段
合作网站：C语言提供了几个标准库函数，可以将任意类型(整型、长整型、浮点型等)的数字转换为字符串。
1.int/float to string/array:
C语言提供了几个标准库函数，可以将任意类型(整型、长整型、浮点型等)的数字转换为字符串，下面列举了各函数的方法及其说明。
● itoa()：将整型值转换为字符串。
● ltoa()：将长整型值转换为字符串。
● ultoa()：将无符号长整型值转换为字符串。
● gcvt()：将浮点型数转换为字符串，取四舍五入。
● ecvt()：将双精度浮点型值转换为字符串，转换结果中不包含十进制小数点。
● fcvt()：指定位数为转换精度，其余同ecvt()。
除此外，还可以使用sprintf系列函数把数字转换成字符串，其比itoa()系列函数运行速度慢2. string/array to int/floatC/C++语言提供了几个标准库函数，可以将字符串转换为任意类型(整型、长整型、浮点型等)。
● atof()：将字符串转换为双精度浮点型值。
● atoi()：将字符串转换为整型值。
● atol()：将字符串转换为长整型值。
● strtod()：将字符串转换为双精度浮点型值，并报告不能被转换的所有剩余数字。
● strtol()：将字符串转换为长整值，并报告不能被转换的所有剩余数字。
● strtoul()：将字符串转换为无符号长整型值，并报告不能被转换的所有剩余数字。
以下是用itoa()函数将整数转换为字符串的一个例子：
# include &stdio.h&
# include &stdlib.h&
void main (void)
int num = 100;
char str[25];
itoa(num, str, 10);
printf("The number 'num' is %d and the string 'str' is %s. \n" ,
num, str);
itoa()函数有3个参数：第一个参数是要转换的数字，第二个参数是要写入转换结果的目标字符串，第三个参数是转移数字时所用 的基数。在上例中，转换基数为10。10：十进制；2：二进制...
itoa并不是一个标准的C函数，它是Windows特有的，如果要写跨平台的程序，请用sprintf。是Windows平台下扩展的，标准库中有sprintf，功能比这个更强，用法跟printf类似：
char str[255];
sprintf(str, "%x", 100); //将100转为16进制表示的字符串。
下列函数可以将整数转换为字符串：
----------------------------------------------------------
----------------------------------------------------------
itoa() 将整型值转换为字符串
itoa() 将长整型值转换为字符串
ultoa() 将无符号长整型值转换为字符串
一、atoi()&&把字符串转换成整型数
考点：字符串转换为数字时，对相关ASCII码的理解。
#include &ctype.h&
#include &stdio.h&
int atoi (char s[]);
int main(void )
char s[100];
printf("integer=%d\n",atoi(s));
int atoi (char s[])
for(i=0;isspace(s[i]);i++)//跳过空白符;
sign=(s[i]=='-')?-1:1;
if(s[i]=='+'||s[i]==' -')//跳过符号
for(n=0;isdigit(s[i]);i++)
&&&&&&&n=10*n+(s[i]-'0');//将数字字符转换成整形数字
return sign *n;
}C++实现：
1&&& #include &iostream&
4&&& int str2int(const char *str)
6&&&&&&& int temp = 0;
7&&&&&&& const char *ptr =& //ptr保存str字符串开头
9&&&&&&& if (*str == '-' || *str == '+')& //如果第一个字符是正负号，
10&&&&&& {&&&&&&&&&&&&&&&&&&&&& //则移到下一个字符
11&&&&&&&&&& str++;
12&&&&&& }
13&&&&&& while(*str != 0)
14&&&&&& {
15&&&&&&&&&& if ((*str & '0') || (*str & '9'))& //如果当前字符不是数字
16&&&&&&&&&& {&&&&&&&&&&&&&&&&&&&&&& //则退出循环
17&&&&&&&&&&&&&&
18&&&&&&&&&& }
19&&&&&&&&&& temp = temp * 10 + (*str - '0'); //如果当前字符是数字则计算数值
20&&&&&&&&&& str++;&&&&& //移到下一个字符
21&&&&&& }&&
22&&&&&& if (*ptr == '-')&&&& //如果字符串是以&-&开头，则转换成其相反数
23&&&&&& {
24&&&&&&&&&& temp = -
25&&&&&& }
30&& int main()
32&&&&&& int n = 0;&&
33&&&&&& char p[10] = "";
35&&&&&& cin.getline(p, 20);&& //从终端获取一个字符串
36&&&&&& n = str2int(p);&&&&& //把字符串转换成整型数
38&&&&&& cout && n &&
40&&&&&& return 0;
41&& }二、itoa()&&把一整数转换为字符串
通过把整数的各位上的数字加&0&转换成char类型并存到字符数组中。但是要注意，需要采用字符串逆序的方法
C语言实现：
#include &ctype.h&
#include &stdio.h&
void&&&&& itoa (int n,char s[]);
//atoi 函数：将ｓ转换为整形数
int main(void )
char s[100];
printf("Input n:\n");
scanf("%d",&n);
printf("the string : \n");
itoa (n,s);
void itoa (int n,char s[])
if((sign=n)&0)//记录符号
n=-n;//使n成为正数
&&&&&&&s[i++]=n%10+'0';//取下一个数字
while ((n/=10)&0);//删除该数字
if(sign&0)
s[i++]='-';
s[i]='\0';
for(j=i;j&=0;j--)//生成的数字是逆序的，所以要逆序输出
&&&&&& printf("%c",s[j]);
是int 转string类型的一个函数
1&&& #include &iostream&
4&&& void int2str(int n, char *str)
6&&& &&&&char buf[10] = "";
7&&& &&&&int i = 0;
8&&& &&&&int len = 0;
9&&& &&&&int temp = n & 0 ? -n:& // temp为n的绝对值
11&& &&&&if (str == NULL)
12&& &&&&{
13&& &&&&&&&&
14&& &&&&}
15&& &&&&while(temp)
16&& &&&&{
17&& &&&&&&&&buf[i++] = (temp % 10) + '0';& //把temp的每一位上的数存入buf
18&& &&&&&&&&temp = temp / 10;
19&& &&&&}
21&& &&&&len = n & 0 ? ++i:& //如果n是负数，则多需要一位来存储负号
22&& &&&&str[i] = 0;&&&&&&&&&&& //末尾是结束符0
23&& &&&&while(1)
24&& &&&&{
25&& &&&&&&&&i--;
26&& &&&&&&&&if (buf[len-i-1] ==0)
27&& &&&&&&&&{
28&& &&&&&&&&&&&&
29&& &&&&&&&&}
30&& &&&&&&&&str[i] = buf[len-i-1];& //把buf数组里的字符拷到字符串
31&& &&&&}
32&& &&&&if (i == 0 )
33&& &&&&{
34&& &&&&&&&&str[i] = '-';&&&&&&&&& //如果是负数，添加一个负号
35&& &&&&}
38&& int main()
40&& &&&&int nN
41&& &&&&char p[10];
43&& &&&&cout && "Please input an integer:";
44&& &&&&cin && nN
45&& &&&&cout && "output: " ;
46&& &&&&int2str(nNum, p);&&&&&&& //整型转换成字符串
47&& &&&&cout&& p &&
49&& &&&&return 0;
参考阅读：http://blog.sina.com.cn/s/blog_4c8a2a870100qgq7.html
阅读(...) 评论()Implement your own itoa() - GeeksforGeeks
Recommended Posts:
( to Rate)
Average Difficulty : 4/5.0Based on 12 vote(s)
Add to TODO List
Mark as DONE
Writing code in comment? Please use , generate link and share the link here.
Share this post!
Trending Content
Most Visited Posts
Popular Categoriessprintf_百度百科
清除历史记录关闭
声明：百科词条人人可编辑，词条创建和修改均免费，绝不存在官方及代理商付费代编，请勿上当受骗。
sprintf指的是字符串格式化命令，主要功能是把格式化的数据写入某个字符串中。sprintf 是个函数。使用sprintf 对于写入buffer的字符数是没有限制的，这就存在了buffer溢出的可能性。
sprintf函数信息
sprintf功能
把格式化的数据写入某个。
sprintf头文件
sprintf原型
int sprintf( char *buffer, const char *format, [ argument] … );
sprintf参数列表
buffer：型指针，指向将要写入的字符串的缓冲区。
format：格式化字符串。
[argument]...：可选参数，可以是任何类型的数据。
sprintf返回值
返回写入buffer 的字符数，出错则返回-1. 如果 buffer 或 format 是空指针，且不出错而继续，函数将返回-1，并且 errno 会被设置为 EINVAL。
sprintf 返回以format为格式argument为内容组成的结果被写入buffer 的字节数，结束字符‘\0’不计入内。即，如果“Hello”被写入空间足够大的buffer后，函数sprintf 返回5。
同时buffer的内容将被改变。
sprintf相关函数
int&sprintf_s(char&*buffer,size_t&sizeOfBuffer,const&char&*format,&[argument]&...&);
int&_sprintf_s_l(char&*buffer,size_t&sizeOfBuffer,const&char&*format,locale_t&locale&,[argument]&...&);
int&swprintf_s(wchar_t&*buffer,size_t&sizeOfBuffer,const&wchar_t&*format&,[argument]...);
int&_swprintf_s_l(wchar_t&*buffer,size_t&sizeOfBuffer,const&wchar_t&*format,locale_t&locale&,[argument]…);
template&&size_t&size&
int&sprintf_s(char&(&buffer)[size],const&char&*format,&[argument]&...&);&//仅存在于C++
template&&size_t&size&
int&swprintf_s(wchar_t&(&buffer)[size],const&wchar_t&*format&,[argument]...);&//仅存在于C++
解决这个问题，可以考虑使用 函数，该函数可对写入字符数做出限制。
sprintf说明及应用
//&crt_sprintf.c
//&compile&with:&/W3
//&This&program&uses&sprintf&to&format&various
//data&and&place&them&in&the&string&named&buffer.
//&程序使用sprintf&将各种数据格式化后置于字符数组buffer中
#include&&stdio.h&
int&main(&void&)
&&&char&&buffer[200],&s[]&=&&computer&,&c&=&'l';
&&&int&&&i&=&35,&j;
&&&float&fp&=&1.7320534f;
&&&//&格式化并打印各种数据到buffer
&&&j&&=&sprintf(&buffer,&&&&&&&&String:&&&&%s\n&,&s&);&//&C4996
&&&j&+=&sprintf(&buffer&+&j,&&&&&Character:&%c\n&,&c&);&//&C4996
&&&j&+=&sprintf(&buffer&+&j,&&&&&Integer:&&&%d\n&,&i&);&//&C4996
&&&j&+=&sprintf(&buffer&+&j,&&&&&Real:&&&&&&%f\n&,&fp&);//&C4996
&&&printf(&&Output:\n%s\ncharacter&count&=&%d\n&,&buffer,&j&);
String: computer 　　
Character: l
Integer: 35
Real: 1.732053
character count = 79
_________________________________________________________________________
sprintf格式的规格如下所示。[]中的部分是可选的。
%[指定参数][][宽度][.精度]指示符
若想输出'%'本身时, 请使用'%%'处理。
1. 处理字符方向。负号时表示从后向前处理。
2. 填空字元。 0 的话表示空格填 0；空格是内定值，表示空格就放着。
3. 总宽度。为最小宽度。
4. 精确度。指在小数点后的浮点数位数。
%% 印出百分比符号，不转换。
%c 整数转成对应的 ASCII 字元。
%d 整数转成十进位。
%f 倍精确度数字转成浮点数。
%o 整数转成八进位。
%s 整数转成字符串。
%x 整数转成小写十六进位。
%X 整数转成大写十六进位。
$money = 123.1
$formatted = sprintf (&%06.2f&, $money); // 此时变数 $ formatted 值为 &123.10&
$formatted = sprintf (&%08.2f&, $money); // 此时变数 $ formatted 值为 &00123.10&
$formatted = sprintf (&%-08.2f&, $money); // 此时变数 $ formatted 值为 &123.1000&
$formatted = sprintf (&%.2f%%&, 0.95 * 100); // 格式化为百分比
%08.2f 解释:
0是 &填空字元& 表示,如果长度不足时就用0来填满。
8格式化后总长度
2f小数位长度，即2位
第3行值为&00123.10& 解释:
因为2f是(2位)+小数点符号(1位)+前面123(3位)=6位，总长度为8位,故前面用[填空字元]0表示，即00123.10
第4行值为&123.1000& 解释:
-号为反向操作，然后填空字元0添加在最后面了
在将各种类型的数据构造成字符串时，sprintf 的强大功能很少会让你失望。由于sprintf 跟printf 在用法上几乎一样，只是打印的目的地不同而已，前者打印到字符串中，后者则直接在命令行上输出。这也导致sprintf 比printf 有用得多。
sprintf 是个函数，定义如下：
int sprintf( char *buffer, const char *format [, argument] ... );
除了前两个参数类型固定外，后面可以接任意多个参数。而它的精华，显然就在第二个参数：
格式化字符串上。
printf 和sprintf 都使用格式化字符串来指定串的格式，在格式串内部使用一些以“%”开头的格式说明符（format specifications）来占据一个位置，在后边的列表中提供相应的变量，最终函数就会用相应位置的变量来替代那个说明符，产生一个调用者想要的字符串。
格式化数字字符串
sprintf 最常见的应用之一莫过于把整数打印到字符串中，所以，sprintf 在大多数场合可以替代
//把整数123 打印成一个字符串保存在s 中。
sprintf(s, &%d&, 123); //产生&123&
可以指定宽度，不足的左边补空格：
sprintf(s, &%4d%4d&, 123, 4567); //产生：& 1234567&
当然也可以左对齐：
sprintf(s, &%-4d%4d&, 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); //产生：&&
上面以”%d”进行的10 进制打印同样也可以使用这种左边补0 的方式。
这里要注意一个符号扩展的问题：比如，假如我们想打印短整数（short）-1 的内存16 进制表示形式，在Win32 平台上，一个short 型占2 个，所以我们自然希望用4 个16 进制数字来打印它：
short si = -1;
sprintf(s, &%04X&, si);
产生“FFFFFFFF”，怎么回事？因为sprintf 是个函数，除了前面两个参数之外，后面的参数都不是的，函数更没有办法仅仅通过一个“%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 进制表示。
控制浮点数打印格式
浮点数的打印和格式控制是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 个就被不由分说地强行作为浮点数格式来解释了，整个乱套了。不过，如果有人有兴趣使用手工编码一个浮点数，那么倒可以使用这种方法来检验一下你手工编排的结果是否正确。
字符/Ascii码
我们知道，在C/C++语言中，char 也是一种普通的scalable 类型，除了之外，它与short，int，long 这些类型没有本质区别，只不过被大家习惯用来表示字符和字符串而已。（或许当年该把这个类型叫做“byte”，然后现在就可以根据实际情况，使用byte 或short 来把char 通过typedef 定义出来，这样更合适些）于是，使用”%d”或者”%x”打印一个字符，便能得出它的10 进制或16 进制的ASCII 码；反过来，使用”%c”打印一个整数，便可以看到它所对应的字符。
以下把所有可见字符的ASCII 码对照表打印到屏幕上（这里采用printf，注意”#”与”%X”合用时自动为16 进制数增加”0X”前缀）：
for(int&i&=&32;&i&&&127;&i++)&{
printf(&[&%c&]:&%3d&0x%#04X\n&,&i,&i,&i);
连接字符串
sprintf 的格式控制串中既然可以插入各种东西，并最终把它们“连成一串”，自然也就能够连接字符串，从而在许多场合可以替代strcat，但sprintf 能够一次连接多个字符串（自然也可以同时在它们中间插入别的内容，总之非常灵活）。比如：
char&buf[60]={0};
char*who=&I&;
char*whom=&CSDN&;
sprintf(buf,&%slove%s.&,who,whom);
printf(&%s&,buf);
//输出结果：&IloveCSDN.&
strcat 只能连接字符串（一段以'\0'结尾的字符或叫做字符缓冲，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&
打印地址信息
有时时，我们可能想查看某些变量或者成员的地址，由于地址或者也不过是个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 函数的返回值，但有时它却是有用的，sprintf 返回了本次最终打印到字符中的字符数目。也就是说每当一次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));
&&&&chars[64];
&&&&int&offset=0;
&&&&for(int&i=0;i&10;i++)
&&&&offset+=sprintf(s+offset,&%d,&,rand()%100);
&&&&s[offset-1]='\n';//将最后一个逗号换成换行符。
&&&&printf(s);
&&&&return&0;
设想当你从数据库中取出一条记录，然后希望把他们的各个字段按照某种规则连接成一个字符串时，就可以使用这种方法，从理论上讲，他应该比不断的strcat 效率高，因为strcat 每次调用都需要先找到最后的那个’’的位置，而在上面给出的例子中，我们每次都利用sprintf 返回值把这个位置直接记下来了。
MSDN中例子：
//crt_sprintf.c
//compile&with:/W3
//This&program&uses&sprintf&to&format&various
//data&and&place&them&in&the&string&name&dbuffer.
#include&stdio.h&
int&main(void)
&&&&char&buffer[200],s[]=&computer&,c='l';
&&&&int&i=35,j;
&&&&float&fp=1.7320534f;//Format&and&print&various&data:
&&&&j=sprintf(buffer,&String:%s\n&,s);//C4996
&&&&j+=sprintf(buffer+j,&Character:%c\n&,c);//C4996
&&&&j+=sprintf(buffer+j,&Integer:%d\n&,i);//C4996
&&&&j+=sprintf(buffer+j,&Real:%f\n&,fp);//C4996
//Note:sprintf&is&&consider&using&sprintf_s&instead
&&&&printf(&Output:\n%s\ncharactercount=%d\n&,buffer,j);
String:computer
Character:l
Integer:35
Real:1.732053
charactercount=53
sprintf常见问题
sprintf 是个函数，使用时经常出问题，而且只要出问题通常就是能导致程序崩溃的内存访问错误，但好在由sprintf 误用导致的问题虽然严重，却很容易找出，无非就是那么几种情况，通常用眼睛再把出错的代码多看几眼就看出来了。
第一个参数的长度太短了，没的说，给个大点的地方吧。当然也可能是后面的参数的问题，建议变参对应一定要细心，而打印串时，尽量使用”%.ns”的形式指定最大字符数。
忘记了第一个参数
低级得不能再低级问题，用printf 用得太惯了。
变参对应出问题
通常是忘记了提供对应某个格式符的，导致以后的参数统统错位，检查检查吧。尤其是对应”*”的那些参数，都提供了吗？不要把一个整数对应一个”%s”，会觉得你欺她太甚了。
sprintf_s和snprintf
()是sprintf()的安全版本，通过指定长度来避免sprintf()存在的溢出风险 。在使用VS2008时如果你使用了sprintf函数，那么编译器会发出警告：使用sprintf存在风险，建议使用sprintf_s。这个安全版本的原型是：
int sprintf_s(char *buffer,size_t sizeOfBuffer,const char *format [,argument] ... );
不过sprintf_s()是微软私有的函数，考虑到跨平台移植，最好使用snprintf()。两者的原型基本相同：
int _snprintf(char *buffer, size_t count, const char *format [,argument] ... );
sprintf 还有个不错的表妹：strftime，专门用于格式化时间字符串的，用法跟她表哥很像，也是一大堆格式控制符，只是毕竟小姑娘家心细，她还要调用者指定的最大长度，可能是为了在出现问题时可以推卸责任吧。这里举个例子：
time_t t = time(0);
//产生&YYYY-MM-DD hh:mm:ss&格式的字符串。
char s[32];
strftime(s, sizeof(s), &%Y-%m-%d %H:%M:%S&, localtime(&t));
sprintf 在MFC 中也能找到他的知音：CString::Format，strftime 在MFC 中自然也有她的同道：CTime::Format，这一对由于从那里得到了赞助，用以写出的代码更觉优雅。
．msdn.microsoft.com[引用日期]
清除历史记录关闭}