資料一

描述

C 庫函數?int sprintf(char *str, const char *format, ...)?發送格式化輸出到?str?所指向的字符串。

聲明

下面是 sprintf() 函數的聲明。

int sprintf(char *str, const char *format, ...)

參數

• str?-- 這是指向一個字符數組的指針，該數組存儲了 C 字符串。
• format?-- 這是字符串，包含了要被寫入到字符串 str 的文本。它可以包含嵌入的 format 標簽，format 標簽可被隨后的附加參數中指定的值替換，并按需求進行格式化。format 標簽屬性是?%[flags][width][.precision][length]specifier，具體講解如下：

specifier（說明符）輸出

c	字符
d 或 i	有符號十進制整數
e	使用 e 字符的科學科學記數法（尾數和指數）
E	使用 E 字符的科學科學記數法（尾數和指數）
f	十進制浮點數
g	自動選擇 %e 或 %f 中合適的表示法
G	自動選擇 %E 或 %f 中合適的表示法
o	有符號八進制
s	字符的字符串
u	無符號十進制整數
x	無符號十六進制整數
X	無符號十六進制整數（大寫字母）
p	指針地址
n	無輸出
%	字符

flags（標識）描述

-	在給定的字段寬度內左對齊，默認是右對齊（參見 width 子說明符）。
+	強制在結果之前顯示加號或減號（+ 或 -），即正數前面會顯示 + 號。默認情況下，只有負數前面會顯示一個 - 號。
(space)	如果沒有寫入任何符號，則在該值前面插入一個空格。
#	與 o、x 或 X 說明符一起使用時，非零值前面會分別顯示 0、0x 或 0X。 與 e、E 和 f 一起使用時，會強制輸出包含一個小數點，即使后邊沒有數字時也會顯示小數點。默認情況下，如果后邊沒有數字時候，不會顯示顯示小數點。 與 g 或 G 一起使用時，結果與使用 e 或 E 時相同，但是尾部的零不會被移除。
0	在指定填充 padding 的數字左邊放置零（0），而不是空格（參見 width 子說明符）。

width（寬度）描述

(number)	要輸出的字符的最小數目。如果輸出的值短于該數，結果會用空格填充。如果輸出的值長于該數，結果不會被截斷。
*	寬度在 format 字符串中未指定，但是會作為附加整數值參數放置于要被格式化的參數之前。

.precision（精度）描述

.number	對于整數說明符（d、i、o、u、x、X）：precision 指定了要寫入的數字的最小位數。如果寫入的值短于該數，結果會用前導零來填充。如果寫入的值長于該數，結果不會被截斷。精度為 0 意味著不寫入任何字符。 對于 e、E 和 f 說明符：要在小數點后輸出的小數位數。 對于 g 和 G 說明符：要輸出的最大有效位數。 對于 s: 要輸出的最大字符數。默認情況下，所有字符都會被輸出，直到遇到末尾的空字符。 對于 c 類型：沒有任何影響。 當未指定任何精度時，默認為 1。如果指定時不帶有一個顯式值，則假定為 0。
.*	精度在 format 字符串中未指定，但是會作為附加整數值參數放置于要被格式化的參數之前。

length（長度）描述

h	參數被解釋為短整型或無符號短整型（僅適用于整數說明符：i、d、o、u、x 和 X）。
l	參數被解釋為長整型或無符號長整型，適用于整數說明符（i、d、o、u、x 和 X）及說明符 c（表示一個寬字符）和 s（表示寬字符字符串）。
L	參數被解釋為長雙精度型（僅適用于浮點數說明符：e、E、f、g 和 G）。

• 附加參數?-- 根據不同的 format 字符串，函數可能需要一系列的附加參數，每個參數包含了一個要被插入的值，替換了 format 參數中指定的每個 % 標簽。參數的個數應與 % 標簽的個數相同。

返回值

如果成功，則返回寫入的字符總數，不包括字符串追加在字符串末尾的空字符。如果失敗，則返回一個負數。

實例

下面的實例演示了 sprintf() 函數的用法。

#include <stdio.h> #include <math.h>int main() {char str[80];sprintf(str, "Pi 的值 = %f", M_PI);puts(str);return(0); }

讓我們編譯并運行上面的程序，這將產生以下結果：

Pi 的值 = 3.141593

資料二

在將各種類型的數據構造成字符串時，sprintf 的強大功能很少會讓你失望。由于sprintf 跟printf 在用法上幾乎一樣，只是打印的目的地不同而已，前者打印到字符串中，后者則直接在命令行上輸出。這也導致sprintf 比printf 有用得多。

sprintf 是個變參函數，定義如下：
int sprintf( char *buffer, const char *format [, argument] ... );
除了前兩個參數類型固定外，后面可以接任意多個參數。而它的精華，顯然就在第二個參數：
(1)格式化字符串上。
printf 和sprintf 都使用格式化字符串來指定串的格式，在格式串內部使用一些以“%”開頭的格式說明符（format specifications）來占據一個位置，在后邊的變參列表中提供相應的變量，最終函數就會用相應位置的變量來替代那個說明符，產生一個調用者想要的字符串。
格式化數字字符串
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 進制表示。
控制浮點數打印格式
浮點數的打印和格式控制是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 個字節就被不由分說地強行作為浮點數格式來解釋了，整個亂套了。不過，如果有人有興趣使用手工編碼一個浮點數，那么倒可以使用這種方法來檢驗一下你手工編排的結果是否正確。

資料三

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個字節就被不由分說地強行作為浮點數格式來解釋了，整個亂套了。 不過，如果有人有興趣使用手工編碼一個浮點數，那么倒可以使用這種方法來檢驗一下你手工編排的結果是否正確。J 字符/Ascii碼對照 我們知道，在C/C++語言中，char也是一種普通的scalable類型，除了字長之外，它與short，int，long這些類型沒有本質區別，只 不過被大家習慣用來表示字符和字符串而已。（或許當年該把這個類型叫做“byte”，然后現在就可以根據實際情況，使用byte或short來把char 通過typedef定義出來，這樣更合適些） 于是，使用”%d”或者”%x”打印一個字符，便能得出它的10進制或16進制的ASCII碼；反過來，使用”%c”打印一個整數，便可以看到它所對應的 ASCII字符。

int snprintf(char *restrict buf, size_t n, const char * restrict??format, ...);

函數說明:最多從源串中拷貝n－1個字符到目標串中，然后再在后面加一個0。所以如果目標串的大小為n 的話，將不會溢出。

函數返回值:若成功則返回欲寫入的字符串長度，若出錯則返回負值。

Result1(推薦的用法)

#include <stdio.h>
#include <stdlib.h>

int main()
{
???? char str[10]={0,};
???? snprintf(str, sizeof(str?)?, "0123456789012345678");
???? printf("str=%s/n", str);
???? return 0;
}

root] /root/lindatest
$ ./test?
str=012345678

Result2:(不推薦使用)

#include <stdio.h>
#include <stdlib.h>

int main()
{
??? char str[10]={0, };
??? snprintf(str, 18, "0123456789012345678");
??? printf("str=%s/n", str);
??? return 0;
}

root] /root/lindatest
$ ./test
str=01234567890123456

snprintf函數返回值的測試：

#include <stdio.h>
#include <stdlib.h>

int main()
{
??? char str1[10] ={0, };
??? char str2[10] ={0, };
??? int ret1=0,ret2=0;
??? ret1=snprintf(str1, sizeof(str1), "%s", "abc");
??? ret2=snprintf(str2, 4, "%s", "aaabbbccc");
??? printf("aaabbbccc length=%d/n", strlen("aaabbbccc"));
??? printf("str1=%s,ret1=%d/n", str1, ret1);
??? printf("str2=%s,ret2=%d/n", str2, ret2);
??? return 0;
}

[root] /root/lindatest
$ ./test?
aaabbbccc length=9
str1=abc,ret1=3
str2=aaa,ret2=9

解釋SIZE：

?#include <stdio.h>
#include <stdlib.h>
int main()
{
char dst1[10] ={0, },dst2[10] ={0, };
char src1[10] ="aaa",src2[15] ="aaabbbcccddd";
int size=sizeof(dst1);
int ret1=0, ret2=0;
ret1=snprintf(dst1, size, "str :%s", src1);
ret2=snprintf(dst2, size, "str :%s", src2);
printf("sizeof(dst1)=%d, src1=%s, /"str :%%s/"=%s%s, dst1=%s, ret1=%d/n", sizeof(dst1), src1, "str :", src1, dst1, ret1);
printf("sizeof(dst2)=%d, src2=%s, /"str :%%s/"=%s%s, dst2=%s, ret2=%d/n", sizeof(dst2), src2, "str :", src2, dst2, ret2);
return 0;
}
root] /root/lindatest
$ ./test?
sizeof(dst1)=10, src1=aaa, "str :%s"=str :aaa, dst1=str :aaa, ret1=8
sizeof(dst2)=10, src2=aaabbbcccddd, "str :%s"=str :aaabbbcccddd, dst2=str :aaab, ret2=17

補充一下，snprintf的返回值是欲寫入的字符串長度，而不是實際寫入的字符串度。如：
char test[8];
int ret = snprintf(test,5,"1234567890");
printf("%d|%s/n",ret,test);

運行結果為：
10|1234

數原型：
int snprintf(char *str, size_t size, const char *format, ...);

? size 的作用就是限制往str寫入不超過size個字節(包括了結尾的'/0')。 因為sprintf()函數如果成功的話，返回成功寫入的字節數(字符數)，我就一直以為snprintf()函數也是如此，也就是snprintf()函數不會返回大于size的整數。 ? 看下面一段手冊內容： ? The functions snprintf() and vsnprintf() do not? write? more than size bytes (including the trailing ’/0’). If the output was truncated due to this limit then the return value is the number of? characters (not including the trailing ’/0’) which would have been written to the final string if enough space had been? available.? Thus,? a? return value? of? size? or more means that the output was truncated. ? 如果輸出因為size的限制而被截斷，返回值將是“如果有足夠空間存儲，所?應?能輸出的字符數(不包括字符串結尾的'/0')”，這個值和size相等或者比size大！也就是說，如果可以寫入的字符串是"0123456789ABCDEF"?共16位，但是size限制了是10，這樣 snprintf() 的返回值將會是16?而不是?10?！ ? 上面的內容還說，如果返回值等于或者大于size，則表明輸出字符串被截斷了(truncated)。

資料四

在將各種類型的數據構造成字符串時，sprintf 的強大功能很少會讓你失望。由于sprintf 跟printf 在用法上幾乎一樣，只是打印的目的地不同而已，前者打印到字符串中，后者則直接在命令行上輸出。這也導致sprintf 比printf 有用得多。
　　sprintf 是個變參函數，定義如下：
　　int sprintf( char *buffer, const char *format [, argument] ... );
　　除了前兩個參數類型固定外，后面可以接任意多個參數。而它的精華，顯然就在第二個參數：

　　(1)格式化字符串上。

　　printf 和sprintf 都使用格式化字符串來指定串的格式，在格式串內部使用一些以“%”開頭的格式說明符（format specifications）來占據一個位置，在后邊的變參列表中提供相應的變量，最終函數就會用相應位置的變量來替代那個說明符，產生一個調用者想要的字符串。
　　格式化數字字符串
　　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 進制表示。
　　控制浮點數打印格式
　　浮點數的打印和格式控制是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 個字節就被不由分說地強行作為浮點數格式來解釋了，整個亂套了。不過，如果有人有興趣使用手工編碼一個浮點數，那么倒可以使用這種方法來檢驗一下你手工編排的結果是否正確。

資料五

將字串格式化命令。sprintf 是個變參函數，使用時經常出問題，而且只要出問題通常就是能導致程序崩潰的內存訪 問錯誤，但好在由sprintf 誤用導致的問題雖然嚴重，卻很容易找出，無非就是那么幾種情況，通 常用眼睛再把出錯的代碼多看幾眼就看出來了。

　　sprintf 將字串格式化。

　　在頭文件 #include<stdio.h

　　>中

　　語法: int sprintf(string format, mixed [args]...);

　　返回值：字符串長度（strlen）

　　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添加在最后面了

　　/********************************************************

　　以下選自《CSDN 社區電子雜志——C/C++雜志》

　　*********************************************************/

　　在將各種類型的數據構造成字符串時，sprintf 的強大功能很少會讓你失望。由于sprintf 跟printf 在用法上幾乎一樣，只是打印的目的地不同而已，前者打印到字符串中，后者則直接在命令行上輸出。這也導致sprintf 比printf 有用得多。

　　sprintf 是個變參函數，定義如下：

　　int sprintf( char *buffer, const char *format [, argument] ... );

　　除了前兩個參數類型固定外，后面可以接任意多個參數。而它的精華，顯然就在第二個參數：

　　格式化字符串上。

　　printf 和sprintf 都使用格式化字符串來指定串的格式，在格式串內部使用一些以“%”開頭的格式說明符（format specifications）來占據一個位置，在后邊的變參列表中提供相應的變量，最終函數就會用相應位置的變量來替代那個說明符，產生一個調用者想要的字符串。

　　格式化數字字符串

　　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 進制表示。

　　控制浮點數打印格式

　　浮點數的打印和格式控制是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 字符。以下程序段把所有可見字符的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* 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"

　　打印地址信息

　　有時調試程序時，我們可能想查看某些變量或者成員的地址，由于地址或者指針也不過是個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

　　#include

　　#include

　　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] = '/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 named buffer.

　　#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 deprecated; consider using sprintf_s instead

　　printf( "Output:/n%s/ncharacter count = %d/n", buffer, j );

　　}

　　Copy

　　Output:

　　String: computer

　　Character: l

　　Integer: 35

　　Real: 1.732053

　　character count = 79

　　使用sprintf 的常見問題

　　sprintf 是個變參函數，使用時經常出問題，而且只要出問題通常就是能導致程序崩潰的內存訪

　　問錯誤，但好在由sprintf 誤用導致的問題雖然嚴重，卻很容易找出，無非就是那么幾種情況，通

　　常用眼睛再把出錯的代碼多看幾眼就看出來了。

　　?? 緩沖區溢出

　　第一個參數的長度太短了，沒的說，給個大點的地方吧。當然也可能是后面的參數的問

　　題，建議變參對應一定要細心，而打印字符串時，盡量使用”%.ns”的形式指定最大字符數。

　　?? 忘記了第一個參數

　　低級得不能再低級問題，用printf 用得太慣了。//偶就常犯。：。（

　　?? 變參對應出問題

　　通常是忘記了提供對應某個格式符的變參，導致以后的參數統統錯位，檢查檢查吧。尤

　　其是對應”*”的那些參數，都提供了嗎？不要把一個整數對應一個”%s”，編譯器會覺得你

　　欺她太甚了（編譯器是obj 和exe 的媽媽，應該是個女的，:P）。

　　strftime

　　sprnitf 還有個不錯的表妹：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，這一對由于從面向對象哪里得到了贊助，用以寫出的代碼更覺優雅。

資料六

在將各種類型的數據構造成字符串時，sprintf 的強大功能很少會讓你失望。由于sprintf 跟printf 在用法上幾乎一樣，只是打印的目的地不同而已，前者打印到字符串中，后者則直接在命令行上輸出。這也導致sprintf 比printf 有用得多。
　　sprintf 是個變參函數，定義如下：
　　int sprintf( char *buffer, const char *format [, argument] ... );
　　除了前兩個參數類型固定外，后面可以接任意多個參數。而它的精華，顯然就在第二個參數：

　　(1)格式化字符串上。

　　printf 和sprintf 都使用格式化字符串來指定串的格式，在格式串內部使用一些以“%”開頭的格式說明符（format specifications）來占據一個位置，在后邊的變參列表中提供相應的變量，最終函數就會用相應位置的變量來替代那個說明符，產生一個調用者想要的字符串。
　　格式化數字字符串
　　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 進制表示。
　　控制浮點數打印格式
　　浮點數的打印和格式控制是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 個字節就被不由分說地強行作為浮點數格式來解釋了，整個亂套了。不過，如果有人有興趣使用手工編碼一個浮點數，那么倒可以使用這種方法來檢驗一下你手工編排的結果是否正確。
　　

??? (2)字符/Ascii 碼對照

　　我們知道，在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/n", i, i, i);
　　}

　　(3)連接字符串

　　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"

　　(4)打印地址信息

　　有時調試程序時，我們可能想查看某些變量或者成員的地址，由于地址或者指針也不過是個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);

　　(5)利用sprintf 的返回值

　　較少有人注意printf/sprintf 函數的返回值，但有時它卻是有用的，spritnf 返回了本次函數調用
　　最終打印到字符緩沖區中的字符數目。也就是說每當一次sprinf 調用結束以后，你無須再調用一次
　　strlen 便已經知道了結果字符串的長度。如：
　　int len = sprintf(s, "%d", i);
　　對于正整數來說，len 便等于整數i 的10 進制位數。
　　下面的是個完整的例子，產生10 個[0, 100)之間的隨機數，并將他們打印到一個字符數組s 中，
　　以逗號分隔開。
　　#include
　　#include
　　#include
　　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] = '/n';//將最后一個逗號換成換行符。
　　printf(s);
　　return 0;
　　}
　　設想當你從數據庫中取出一條記錄，然后希望把他們的各個字段按照某種規則連接成一個字
　　符串時，就可以使用這種方法，從理論上講，他應該比不斷的strcat 效率高，因為strcat 每次調用
　　都需要先找到最后的那個’’的位置，而在上面給出的例子中，我們每次都利用sprintf 返回值把這
　　個位置直接記下來了。
　　使用sprintf 的常見問題
　　sprintf 是個變參函數，使用時經常出問題，而且只要出問題通常就是能導致程序崩潰的內存訪
　　問錯誤，但好在由sprintf 誤用導致的問題雖然嚴重，卻很容易找出，無非就是那么幾種情況，通
　　常用眼睛再把出錯的代碼多看幾眼就看出來了。
　　?? 緩沖區溢出
　　第一個參數的長度太短了，沒的說，給個大點的地方吧。當然也可能是后面的參數的問
　　題，建議變參對應一定要細心，而打印字符串時，盡量使用”%.ns”的形式指定最大字符數。
　　?? 忘記了第一個參數
　　低級得不能再低級問題，用printf 用得太慣了。//偶就常犯。：。（
　　?? 變參對應出問題
　　通常是忘記了提供對應某個格式符的變參，導致以后的參數統統錯位，檢查檢查吧。尤
　　其是對應”*”的那些參數，都提供了嗎？不要把一個整數對應一個”%s”，編譯器會覺得你
　　欺她太甚了（編譯器是obj 和exe 的媽媽，應該是個女的，:P）。
　　strftime
　　sprnitf 還有個不錯的表妹：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，這一對由于從面向對象哪里得到了贊助，用以寫出的代碼更覺優雅。

?

?

?

資料七

?

sprintf　用法總結(2009-08-25 09:36:24)標簽：it?? 分類：C++?
　　sprintf,將各種類型的數據夠造成字符串。

　　sprintf是個變參函數，int sprintf(char *buffer,const char *format[,argument]...);除了前兩個參數類型固定外，后面可以接任意多個參數，而它的精華，則在第二個參數：格式化字符串上。

　　printf和sprintf都使用格式化字符串來指定串的格式，在格式串內部使用一些以“％”開頭的格式說明符（format specification）來占據一個位置，在后邊的變參列表中提供相應的變量，最終函數就會用相應位置的變量來替代那個說明符，產生一個調用者想要的字符串。

　一、格式化數字字符串

　　sprintf最常見的應用之一莫過于把整數打印到字符串中，所以sprintf在大多數場合可以替代itoa.

??? %-8d 代表寬度八位，左對齊（沒有負號為右對齊），整數的十進制

　　%x小寫16進制　　%X大寫16進制

??? 符號擴展問題：參數壓棧默認四字節，即８位16進制。應該讓編譯器做0擴展而不是符號擴展。

　　如　 sprintf(s,"%04X",(unsigned short)si);

??? %o 8進制格式化字符串。

　　控制浮點數打印格式，使用格式符"%f"控制，默認保留小數點后６位數字。

　　%m.nf m表示打印的寬度,n表示小數點后的位數

　　sprintf(s,"%m.nf",i)其中i 必須為浮點類型的

二、字符/ASCII碼對照

　　%c打印一個整數，可以看到整數所對應的ASCII值

?　for(int i=32 ;i<127;i++)
?　{
? 　　printf("[%c]:%3d 0x%#04X/n",i,i,i);
?　}

　#與%X合用時自動為16進制數增加“0X”前綴。

三、連接字符串

　可以在許多場合替代strcat，sprintf能夠一次連接多個字符串。

　%s可以參照浮點數控制的%m.n　m表示寬度,n表示從相應的字符串中最多取用的字符數，通常ｍ沒什么用。

　　對于動態的，可以采用sprintf(s,"%.*s%.*s",7,a1,7,a2)或sprintf(s,"%.*s%.*s",sizeof(a1),a1,sizeof(a2),a2);　　

四、打印地址信息

有時調試程序時，我們可能想查看某些變量或者成員的地址，由于地址或者指針也不過是個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);

五、返回值

返回了本次函數調用最終打印到字符緩沖區中的字符數目。?
六、strftime

專門用于格式化時間字符串。需調用者指定緩沖區的最大長度。

strftime(s,sizeof(s),"%Y-%m-%d %H:%M:%S",localtime(&t));

資料八

sprintf

int sprintf ( char * str, const char * format, ... ); Write formatted data to string Composes a string with the same text that would be printed if?format?was used on?printf, but instead of being printed, the content is stored as a?C string?in the buffer pointed by?str.

The size of the buffer should be large enough to contain the entire resulting string (see?snprintf?for a safer version).

A terminating null character is automatically appended after the content.

After the?format?parameter, the function expects at least as many additional arguments as needed for?format.

Parameters

str

Pointer to a buffer where the resulting C-string is stored.
The buffer should be large enough to contain the resulting string.

format

C string that contains a format string that follows the same specifications as?format?in?printf?(see?printf?for details).

...?(additional arguments)

Depending on the?format?string, the function may expect a sequence of additional arguments, each containing a value to be used to replace a?format specifier?in the?format?string (or a pointer to a storage location, for?n).
There should be at least as many of these arguments as the number of values specified in the?format specifiers. Additional arguments are ignored by the function.

Return Value

On success, the total number of characters written is returned. This count does not include the additional null-character automatically appended at the end of the string.
On failure, a negative number is returned.

Example

1 2 3 4 5 6 7 8 9 10 11

/* sprintf example */ #include <stdio.h>int main () {char buffer [50];int n, a=5, b=3;n=sprintf (buffer, "%d plus %d is %d", a, b, a+b);printf ("[%s] is a string %d chars long\n",buffer,n);return 0; }

Edit & Run

Output:

[5 plus 3 is 8] is a string 13 chars long

See also

snprintf

Write formatted output to sized buffer?(function )

printf

Print formatted data to stdout?(function )

sscanf

Read formatted data from string?(function )

總結

以上是生活随笔為你收集整理的整理：C++中sprintf()函数的使用详解的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。