一、前言

在嵌入式項目開發(fā)中，字符串格式化是很常見的操作，我們一般都會使用 C 庫中的 sprintf 系列函數(shù)來完成格式化。

從功能上來說，這是沒有問題的，但是在一些時間關(guān)鍵場合，字符串的格式化效率會對整個系統(tǒng)產(chǎn)生顯著的影響。

例如：在一個日志系統(tǒng)中，吞吐率是一個重要的性能指標(biāo)。每個功能模塊都產(chǎn)生了大量的日志信息，日志系統(tǒng)需要把時間戳添加到每條日志的頭部，此時字符串的格式化效率就比較關(guān)鍵了。

天下武功，唯快不破！

這篇文章就專門來聊一聊把數(shù)字格式化成字符串，可以有什么更好的方法。也許技術(shù)含量不高，但是很實用！

二、最簡單的格式化

#include #include #include #include

int main(){ char buff[32] = { 0 }; sprintf(buff, "%ld", LONG_MAX); printf("buff = %s ", buff);}

其中，LONG_MAX 表示 long 型數(shù)值的最大值。代碼在眨眼功夫之間就執(zhí)行結(jié)束了，但是如果是一百萬、一千萬次呢？

三、測試1：手動格式化數(shù)字

1. 獲取系統(tǒng)時間戳函數(shù)

我的測試環(huán)境是：在 Win10 中通過 VirtualBox，安裝了 Ubuntu16.04 虛擬機(jī)，使用系統(tǒng)自帶的 gcc 編譯器。

為了測試代碼執(zhí)行的耗時，我們寫一個簡單的函數(shù)：獲取系統(tǒng)的時間戳，通過計算時間差值來看一下代碼的執(zhí)行速度。

// 獲取系統(tǒng)時間戳long long getSysTimestamp(){ struct timeval tv; gettimeofday(&tv, 0); long long ts = (long long)tv.tv_sec * 1000000 + tv.tv_usec; return ts; }

2. 實現(xiàn)格式化數(shù)字的函數(shù)

// buff: 格式化之后字符串存儲地址；// value: 待格式化的數(shù)字void Long2String(char *buff, long value){ long tmp; char tmpBuf[32] = { 0 }; // p 指向臨時數(shù)組的最后一個位置 char *p = &tmpBuf[sizeof(tmpBuf) - 1]; while (value != 0) { tmp = value / 10; // 把一個數(shù)字轉(zhuǎn)成 ASCII 碼，放到 p 指向的位置。 // 然后 p 往前移動一個位置。 *--p = (char)('0' + (value - tmp * 10)); value = tmp; } // 把臨時數(shù)組中的每個字符，復(fù)制到 buff 中。 while (*p) *buff++ = *p++;}

這個函數(shù)的過程很簡單，從數(shù)字的后面開始，把每一個數(shù)字轉(zhuǎn)成 ASCII 碼，放到一個臨時數(shù)組中(也是從后往前放)，最后統(tǒng)一復(fù)制到形參指針 buff 指向的空間。

3. 測試代碼

int main(){ printf("long size = %d, LONG_MAX = %ld ", sizeof(long), LONG_MAX); // 測試 1000 萬次 int total = 1000 * 10000; char buff1[32] = { 0 }; char buff2[32] = { 0 }; // 測試 sprintf long long start1 = getSysTimestamp(); for (int i = 0; i < total; ++i) sprintf(buff1, "%ld", LONG_MAX); printf("sprintf ellapse: %lld us ", getSysTimestamp() - start1); // 測試 Long2String long long start2 = getSysTimestamp(); for (int i = 0; i < total; ++i) Long2String(buff2, LONG_MAX); printf("Long2String ellapse: %lld us ", getSysTimestamp() - start2); return 0;}

4. 執(zhí)行結(jié)果對比

long size = 4, LONG_MAX = 2147483647sprintf ellapse: 1675761 us Long2String ellapse: 527728 us

也就是說：把一個 long 型數(shù)字格式化成字符串:

使用 sprintf 庫函數(shù)，耗時 1675761 us;

使用自己寫的 Long2String 函數(shù)，耗時 527728 us；

大概是 3 倍左右的差距。當(dāng)然，在你的電腦上可能會得到不同的結(jié)果，這與系統(tǒng)的負(fù)載等有關(guān)系，可以多測試幾次。

四、測試2：混合格式化字符串和數(shù)字

看起來使用自己寫的 Long2String 函數(shù)執(zhí)行速度更快一些，但是它有一個弊端，就是只能格式化數(shù)字。

如果我們需要把字符串和數(shù)字一起格式化成一個字符串，應(yīng)該如何處理？

如果使用 sprintf 庫函數(shù)，那非常方便：

sprintf(buff, "%s%d", "hello", 123456);

如果繼續(xù)使用 Long2String 函數(shù)，那么就要分步來格式化，例如：

// 拆成 2 個步驟sprintf(buff, "%s", "hello");Long2String(buff + strlen(buff), 123456);

以上兩種方式都能達(dá)到目的，那執(zhí)行效率如何呢？繼續(xù)測試：

int main(){ printf("long size = %d, LONG_MAX = %ld ", sizeof(long), LONG_MAX); // 測試 1000 萬 次 const char *prefix = "ZhangSan has money: "; int total = 1000 * 10000; char buff1[32] = { 0 }; char buff2[32] = { 0 }; // 測試 sprintf long long start1 = getSysTimestamp(); for (int i = 0; i < total; ++i) sprintf(buff1, "%s%ld", prefix, LONG_MAX); printf("sprintf ellapse: %lld us ", getSysTimestamp() - start1); // 測試 Long2String long long start2 = getSysTimestamp(); for (int i = 0; i < total; ++i) { sprintf(buff2, "%s", prefix); Long2String(buff2 + strlen(prefix), LONG_MAX); } printf("Long2String ellapse: %lld us ", getSysTimestamp() - start2); return 0;}

執(zhí)行結(jié)果對比:

long size = 4, LONG_MAX = 2147483647sprintf ellapse: 2477686 us Long2String ellapse: 816119 us

執(zhí)行速度仍然是 3 倍左右的差距。就是說，即使拆分成多個步驟來執(zhí)行，使用 Long2String 函數(shù)也會更快一些！

五、sprintf 的實現(xiàn)機(jī)制

sprintf 函數(shù)家族中，存在著一系列的函數(shù)，其底層是通過可變參數(shù)來實現(xiàn)的。之前寫過一篇文章一個printf(結(jié)構(gòu)體指針)引發(fā)的血案，其中的第四部分，使用圖片詳細(xì)描述了可變參數(shù)的實現(xiàn)原理，摘抄如下。

1. 可變參數(shù)的幾個宏定義

typedef char * va_list; #define va_start _crt_va_start#define va_arg _crt_va_arg #define va_end _crt_va_end #define _crt_va_start(ap,v) ( ap = (va_list)_ADDRESSOF(v) + _INTSIZEOF(v) ) #define _crt_va_arg(ap,t) ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) ) #define _crt_va_end(ap) ( ap = (va_list)0 )

注意：va_list 就是一個 char* 型指針。

2. 可變參數(shù)的處理過程

我們以剛才的示例 my_printf_int 函數(shù)為例，重新貼一下：

void my_printf_int(int num, ...) // step1{ int i, val; va_list arg; va_start(arg, num); // step2 for(i = 0; i < num; i++) { val = va_arg(arg, int); // step3 printf("%d ", val); } va_end(arg); // step4 printf(" ");} int main(){ int a = 1, b = 2, c = 3; my_printf_int(3, a, b, c);}

Step1: 函數(shù)調(diào)用時

C語言中函數(shù)調(diào)用時，參數(shù)是從右到左、逐個壓入到棧中的，因此在進(jìn)入 my_printf_int 的函數(shù)體中時，棧中的布局如下:

Step2: 執(zhí)行 va_start

va_start(arg, num);

把上面這語句，帶入下面這宏定義：

#define_crt_va_start(ap,v)(ap=(va_list)_ADDRESSOF(v)+_INTSIZEOF(v))
宏擴(kuò)展之后得到：

arg = (char *)num + sizeof(num);

結(jié)合下面的圖來分析一下：首先通過 _ADDRESSOF 得到 num 的地址 0x01020300，然后強(qiáng)轉(zhuǎn)成 char* 類型，再然后加上 num 占據(jù)的字節(jié)數(shù)(4個字節(jié))，得到地址 0x01020304，最后把這個地址賦值給 arg，因此 arg 這個指針就指向了棧中數(shù)字 1 的那個地址，也就是第一個參數(shù)，如下圖所示：

Step3: 執(zhí)行 va_arg

val = va_arg(arg, int);

把上面這語句，帶入下面這宏定義：

#define_crt_va_arg(ap,t)(*(t*)((ap+=_INTSIZEOF(t))-_INTSIZEOF(t)))
宏擴(kuò)展之后得到：

val = ( *(int *)((arg += _INTSIZEOF(int)) - _INTSIZEOF(int)) )

結(jié)合下面的圖來分析一下：先把 arg 自增 int 型數(shù)據(jù)的大小(4個字節(jié))，使得 arg = 0x01020308；然后再把這個地址(0x01020308)減去4個字節(jié)，得到的地址(0x01020304)里的這個值，強(qiáng)轉(zhuǎn)成 int 型，賦值給 val，如下圖所示：

簡單理解，其實也就是：得到當(dāng)前 arg 指向的 int 數(shù)據(jù)，然后把 arg 指向位于高地址處的下一個參數(shù)位置。

va_arg 可以反復(fù)調(diào)用，直到獲取棧中所有的函數(shù)傳入的參數(shù)。

Step4: 執(zhí)行 va_end

va_end(arg);

把上面這語句，帶入下面這宏定義：

#define _crt_va_end(ap) ( ap = (va_list)0 )

宏擴(kuò)展之后得到：

arg = (char *)0;

這就好理解了，直接把指針 arg 設(shè)置為空。因為棧中的所有動態(tài)參數(shù)被提取后，arg 的值為 0x01020310(最后一個參數(shù)的上一個地址)，如果不設(shè)置為 NULL 的話，下面使用的話就得到未知的結(jié)果，為了防止誤操作，需要設(shè)置為NULL。

六、總結(jié)

這篇文章描述的格式化方法靈活性不太好，也許存在一定的局限性。但是在一些關(guān)鍵場景下，能明顯提高執(zhí)行效率。

如果文中演示代碼有什么問題，或者你有更好的方法，歡迎分享給大家！

編輯：jq