天下武功,唯快不破:提升字符串格式化效率的小技巧

开发
在嵌入式项目开发中,字符串格式化是很常见的操作,我们一般都会使用 C 库中的 sprintf 系列函数来完成格式化。这篇文章就专门来聊一聊把数字格式化成字符串,可以有什么更好的方法。也许技术含量不高,但是很实用!

[[384892]]

一、前言

在嵌入式项目开发中,字符串格式化是很常见的操作,我们一般都会使用 C 库中的 sprintf 系列函数来完成格式化。

从功能上来说,这是没有问题的,但是在一些时间关键场合,字符串的格式化效率会对整个系统产生显著的影响。

例如:在一个日志系统中,吞吐率是一个重要的性能指标。每个功能模块都产生了大量的日志信息,日志系统需要把时间戳添加到每条日志的头部,此时字符串的格式化效率就比较关键了。

天下武功,唯快不破!

这篇文章就专门来聊一聊把数字格式化成字符串,可以有什么更好的方法。也许技术含量不高,但是很实用!

二、最简单的格式化

  1. #include <stdio.h> 
  2. #include <string.h> 
  3. #include <limits.h> 
  4. #include <sys/time.h> 
  5.  
  6. int main() 
  7.     char buff[32] = { 0 }; 
  8.     sprintf(buff, "%ld", LONG_MAX); 
  9.     printf("buff = %s \n", buff); 

其中,LONG_MAX 表示 long 型数值的最大值。代码在眨眼功夫之间就执行结束了,但是如果是一百万、一千万次呢?

三、测试1:手动格式化数字

1. 获取系统时间戳函数

我的测试环境是:在 Win10 中通过 VirtualBox,安装了 Ubuntu16.04 虚拟机,使用系统自带的 gcc 编译器。

为了测试代码执行的耗时,我们写一个简单的函数:获取系统的时间戳,通过计算时间差值来看一下代码的执行速度。

  1. // 获取系统时间戳 
  2. long long getSysTimestamp() 
  3.     struct timeval tv;   
  4.     gettimeofday(&tv, 0); 
  5.     long long ts = (long long)tv.tv_sec * 1000000 + tv.tv_usec; 
  6.     return ts;  

2. 实现格式化数字的函数

  1. // buff: 格式化之后字符串存储地址; 
  2. // value: 待格式化的数字 
  3. void Long2String(char *buff, long value) 
  4.     long tmp; 
  5.     char tmpBuf[32] = { 0 }; 
  6.     // p 指向临时数组的最后一个位置 
  7.     char *p = &tmpBuf[sizeof(tmpBuf) - 1]; 
  8.      
  9.     while (value != 0) 
  10.     { 
  11.         tmp  = value / 10; 
  12.         // 把一个数字转成 ASCII 码,放到 p 指向的位置。 
  13.         // 然后 p 往前移动一个位置。 
  14.         *--p = (char)('0' + (value - tmp * 10)); 
  15.         value = tmp; 
  16.     } 
  17.  
  18.     // 把临时数组中的每个字符,复制到 buff 中。 
  19.     while (*p) *buff++ = *p++; 
  20. }     

这个函数的过程很简单,从数字的后面开始,把每一个数字转成 ASCII 码,放到一个临时数组中(也是从后往前放),最后统一复制到形参指针 buff 指向的空间。

3. 测试代码

  1. int main() 
  2.     printf("long size = %d, LONG_MAX = %ld\n", sizeof(long), LONG_MAX); 
  3.      
  4.     // 测试 1000 万次 
  5.     int  total = 1000 * 10000; 
  6.     char buff1[32] = { 0 }; 
  7.     char buff2[32] = { 0 }; 
  8.  
  9.     // 测试 sprintf 
  10.     long long start1 = getSysTimestamp(); 
  11.     for (int i = 0; i < total; ++i) 
  12.         sprintf(buff1, "%ld", LONG_MAX); 
  13.     printf("sprintf    ellapse:  %lld us \n", getSysTimestamp() - start1); 
  14.  
  15.     // 测试 Long2String 
  16.     long long start2 = getSysTimestamp(); 
  17.     for (int i = 0; i < total; ++i) 
  18.         Long2String(buff2, LONG_MAX); 
  19.     printf("Long2String ellapse: %lld us \n", getSysTimestamp() - start2); 
  20.      
  21.     return 0; 

4. 执行结果对比

  1. long size = 4, LONG_MAX = 2147483647 
  2. sprintf    ellapse:  1675761 us  
  3. Long2String ellapse: 527728 us 

也就是说:把一个 long 型数字格式化成字符串:

  1. 使用 sprintf 库函数,耗时 1675761 us;
  2. 使用自己写的 Long2String 函数,耗时 527728 us;

大概是 3 倍左右的差距。当然,在你的电脑上可能会得到不同的结果,这与系统的负载等有关系,可以多测试几次。

四、测试2:混合格式化字符串和数字

看起来使用自己写的 Long2String 函数执行速度更快一些,但是它有一个弊端,就是只能格式化数字。

如果我们需要把字符串和数字一起格式化成一个字符串,应该如何处理?

如果使用 sprintf 库函数,那非常方便:

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

如果继续使用 Long2String 函数,那么就要分步来格式化,例如:

  1. // 拆成 2 个步骤 
  2. sprintf(buff, "%s""hello"); 
  3. Long2String(buff + strlen(buff), 123456); 

以上两种方式都能达到目的,那执行效率如何呢?继续测试:

  1. int main() 
  2.     printf("long size = %d, LONG_MAX = %ld\n", sizeof(long), LONG_MAX); 
  3.      
  4.     // 测试 1000 万 次 
  5.     const char *prefix = "ZhangSan has money: "
  6.     int  total = 1000 * 10000; 
  7.     char buff1[32] = { 0 }; 
  8.     char buff2[32] = { 0 }; 
  9.  
  10.     // 测试 sprintf 
  11.     long long start1 = getSysTimestamp(); 
  12.     for (int i = 0; i < total; ++i) 
  13.         sprintf(buff1, "%s%ld", prefix, LONG_MAX); 
  14.     printf("sprintf     ellapse: %lld us \n", getSysTimestamp() - start1); 
  15.  
  16.     // 测试 Long2String 
  17.     long long start2 = getSysTimestamp(); 
  18.     for (int i = 0; i < total; ++i) 
  19.     { 
  20.         sprintf(buff2, "%s", prefix); 
  21.         Long2String(buff2 + strlen(prefix), LONG_MAX); 
  22.     } 
  23.     printf("Long2String ellapse: %lld us \n", getSysTimestamp() - start2); 
  24.      
  25.     return 0; 

执行结果对比:

  1. long size = 4, LONG_MAX = 2147483647 
  2. sprintf     ellapse: 2477686 us  
  3. Long2String ellapse: 816119 us 

执行速度仍然是 3 倍左右的差距。就是说,即使拆分成多个步骤来执行,使用 Long2String 函数也会更快一些!

五、sprintf 的实现机制

sprintf 函数家族中,存在着一系列的函数,其底层是通过可变参数来实现的。之前写过一篇文章一个printf(结构体指针)引发的血案,其中的第四部分,使用图片详细描述了可变参数的实现原理,摘抄如下。

1. 可变参数的几个宏定义

  1. typedef char *    va_list; 
  2.  
  3. #define va_start  _crt_va_start 
  4. #define va_arg    _crt_va_arg   
  5. #define va_end    _crt_va_end   
  6.  
  7. #define _crt_va_start(ap,v)  ( ap = (va_list)_ADDRESSOF(v) + _INTSIZEOF(v) )   
  8. #define _crt_va_arg(ap,t)    ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )   
  9. #define _crt_va_end(ap)      ( ap = (va_list)0 ) 

注意:va_list 就是一个 char* 型指针。

2. 可变参数的处理过程

我们以刚才的示例 my_printf_int 函数为例,重新贴一下:

  1. void my_printf_int(int num, ...) // step1 
  2.     int i, val; 
  3.     va_list arg; 
  4.     va_start(arg, num);         // step2 
  5.     for(i = 0; i < num; i++) 
  6.     { 
  7.         val = va_arg(arg, int); // step3 
  8.         printf("%d ", val); 
  9.     } 
  10.     va_end(arg);                // step4 
  11.     printf("\n"); 
  12.  
  13. int main() 
  14.     int a = 1, b = 2, c = 3; 
  15.     my_printf_int(3, a, b, c); 

Step1: 函数调用时

C语言中函数调用时,参数是从右到左、逐个压入到栈中的,因此在进入 my_printf_int的函数体中时,栈中的布局如下:


Step2: 执行 va_start

  1. va_start(arg, num); 

把上面这语句,带入下面这宏定义:

  1. #define _crt_va_start(ap,v)  ( ap = (va_list)_ADDRESSOF(v) + _INTSIZEOF(v) ) 

宏扩展之后得到:

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

结合下面的图来分析一下:首先通过 _ADDRESSOF 得到 num 的地址 0x01020300,然后强转成 char* 类型,再然后加上 num 占据的字节数(4个字节),得到地址 0x01020304,最后把这个地址赋值给 arg,因此 arg 这个指针就指向了栈中数字 1 的那个地址,也就是第一个参数,如下图所示: 

Step3: 执行 va_arg

  1. val = va_arg(arg, int); 

把上面这语句,带入下面这宏定义:

  1. #define _crt_va_arg(ap,t)    ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) ) 

宏扩展之后得到:

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

结合下面的图来分析一下:先把 arg 自增 int 型数据的大小(4个字节),使得 arg = 0x01020308;然后再把这个地址(0x01020308)减去4个字节,得到的地址(0x01020304)里的这个值,强转成 int 型,赋值给 val,如下图所示:


简单理解,其实也就是:得到当前 arg 指向的 int 数据,然后把 arg 指向位于高地址处的下一个参数位置。

va_arg 可以反复调用,直到获取栈中所有的函数传入的参数。

Step4: 执行 va_end

  1. va_end(arg); 

把上面这语句,带入下面这宏定义:

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

宏扩展之后得到:

  1. arg = (char *)0; 

这就好理解了,直接把指针 arg 设置为空。因为栈中的所有动态参数被提取后,arg 的值为 0x01020310(最后一个参数的上一个地址),如果不设置为 NULL 的话,下面使用的话就得到未知的结果,为了防止误操作,需要设置为NULL。

六、总结

这篇文章描述的格式化方法灵活性不太好,也许存在一定的局限性。但是在一些关键场景下,能明显提高执行效率。

 

责任编辑:姜华 来源: IOT物联网小镇
相关推荐

2018-06-19 16:48:42

华为

2020-06-22 13:43:46

代码编码语言

2021-02-23 10:15:31

软件开发IT领导者首席信息官

2019-09-09 08:40:44

2021-01-26 09:19:58

Redis框架架构

2021-06-09 07:55:18

Python格式化字符串

2020-01-16 16:20:55

网络安全数据技术

2018-04-13 10:36:44

Web应用优化

2022-05-09 14:04:27

Python字符串格式化输出

2009-09-02 15:56:49

C#格式化字符串

2016-08-01 10:38:14

华为

2022-02-21 09:35:36

机器学习自然语言模型

2023-11-06 09:32:52

Java实践

2009-09-03 18:05:04

ASP.NET字符串格

2010-02-01 16:46:07

C++格式化字符串

2024-02-22 09:46:04

C++字符串格式化开发

2009-09-03 18:45:06

GridView格式化

2020-06-28 08:26:41

Python开发工具

2017-01-16 16:33:06

Python 字符串漏洞

2013-06-18 10:52:12

大数据
点赞
收藏

51CTO技术栈公众号