找一个代替sprintf函数的办法

tim4146

我的一个工程中连续用到了30个sprint函数，用来把变量转换成字符的呈现格式发送出去，但是发现耗时达到了500us
效率挺低的，有什么办法能替换这个函数吗？

zxq6

itoa？itoa

yoz

如果你自己实现一个弱功能的sprintf，比如限制浮点转整数的位数，不支持高级的格式控制字符，那应该会快些。

honami520

自己用多个函数合成吧。合成自己需要的特定内容得了。
你自己去写个可能效率很差，说不定更慢

山外メ雲ジ

自己写，快过sprint很多。sprint，会考虑各种情况，所以很多重复动作。

s1j2h3

自己写，很容易的

armstrong

1. static int xvprintf(char buff[], char const * fmt, va_list arp)
   
2. {
   
3.   unsigned int r, i, j, w, f;
   
4.   unsigned long v;
   
5.   char s[16], c, d, *p;
   
6.   char *out = buff;
   
7. 
   
8.   for (;;) {
   
9.     c = *fmt++;                 /* Get a char */
   
10.     if (!c) {
    
11.       break;                    /* End of format? */
    
12.     }
    
13.     if (c != '%') {             /* Pass through it if not a % sequense */
    
14.       *out++ = c;
    
15.       continue;
    
16.     }
    
17.     f = 0;
    
18.     c = *fmt++;                 /* Get first char of the sequense */
    
19.     if (c == '0') {             /* Flag: '0' padded */
    
20.       f = 1;
    
21.       c = *fmt++;
    
22.     } else {
    
23.       if (c == '-') {           /* Flag: left justified */
    
24.         f = 2;
    
25.         c = *fmt++;
    
26.       }
    
27.     }
    
28.     for (w = 0; c >= '0' && c <= '9'; c = *fmt++) {
    
29.       w = w * 10 + c - '0';     /* Minimum width */
    
30.     }
    
31.     if (c == 'l' || c == 'L') { /* Prefix: Size is long int */
    
32.       f |= 4;
    
33.       c = *fmt++;
    
34.     }
    
35.     if (!c) {
    
36.       break;                    /* End of format? */
    
37.     }
    
38.     d = c;
    
39.     if (d >= 'a') {
    
40.       d -= 0x20;
    
41.     }
    
42.     switch (d) {                /* Type is... */
    
43.     case 'S' :                  /* String */
    
44.       p = va_arg(arp, char*);
    
45.       for (j = 0; p[j]; j++);
    
46.       if (!(f & 2) && j < w) {
    
47.         memset(out, ' ', w - j);
    
48.         out += w - j;
    
49.         memcpy(out, p, j);
    
50.         out += j;
    
51.         j = w;
    
52.       } else {
    
53.         memcpy(out, p, j);
    
54.         out += j;
    
55.       }
    
56.       if (j < w) {
    
57.         memset(out, ' ', w - j);
    
58.         out += w - j;
    
59.       }
    
60.       continue;
    
61.     case 'C' :                  /* Character */
    
62.       *out++ = (char)va_arg(arp, int);
    
63.       continue;
    
64.     case 'B' :                  /* Binary */
    
65.       r = 2;
    
66.       break;
    
67.     case 'O' :                  /* Octal */
    
68.       r = 8;
    
69.       break;
    
70.     case 'D' :                  /* Signed decimal */
    
71.     case 'U' :                  /* Unsigned decimal */
    
72.       r = 10;
    
73.       break;
    
74.     case 'X' :                  /* Hexdecimal */
    
75.       r = 16;
    
76.       break;
    
77.     default:                    /* Unknown type (passthrough) */
    
78.       *out++ = c;
    
79.       continue;
    
80.     }
    
81.     /* Get an argument and put it in numeral */
    
82.     if(f & 4){
    
83.         v = va_arg(arp, long);
    
84.     }else{
    
85.         if(d == 'D'){
    
86.             v = (long)va_arg(arp, int);
    
87.         }else{
    
88.             v = va_arg(arp, unsigned int);
    
89.         }
    
90.     }
    
91.     if (d == 'D' && (v & 0x80000000)) {
    
92.       v = 0 - v;
    
93.       f |= 8;
    
94.     }
    
95.     i = 0;
    
96.     do {
    
97.       d = (char)(v % r);
    
98.       v /= r;
    
99.       if (d > 9) {
    
100.         d += (c == 'x') ? 0x27 : 0x07;
     
101.       }
     
102.       s[i++] = d + '0';
     
103.     } while (v && i < sizeof(s));
     
104.     if (f & 8) {
     
105.       s[i++] = '-';
     
106.     }
     
107.     j = i;
     
108.     d = (f & 1) ? '0' : ' ';
     
109.     if (!(f & 2) && j < w) {
     
110.       memset(out, d, w - j);
     
111.       out += w - j;
     
112.       do {
     
113.         *out++ = s[--i];
     
114.       } while(i);
     
115.       j = w;
     
116.     } else {
     
117.       do {
     
118.         *out++ = s[--i];
     
119.       } while(i);
     
120.     }
     
121.     if (j < w) {
     
122.       memset(out, ' ', w - j);
     
123.       out += w - j;
     
124.     }
     
125.   }
     
126.   return ((int)(out - buff));
     
127. }
     
128. 
     
129. int xsprintf(char* buff, char const * fmt, ...)
     
130. {
     
131.   va_list arp;
     
132.   int len;
     
133. 
     
134.   va_start(arp, fmt);
     
135.   len = xvprintf(buff, fmt, arp);
     
136.   va_end(arp);
     
137.   buff[len] = 0;
     
138.   return len;
     
139. }

复制代码

xyz543

推荐自己写个，将较常用的判断放在较前面，效率估计会快很多，有点类似手机跑分作弊的方法。

tomzbj

试试elm-chan的xprintf库？不过他的不支持浮点。

Earthman

我一般自己写，标准库动辄引入1~2kB甚至更多，占用空间而且非常慢

kinsno

armstrong 发表于 2019-4-8 20:04

我找了半天，特地在找'f' ， 好象没找到。。是不是不支持浮点数。。

了无

同求，我现在用的库里面的，而且还不支持浮点数

tim4146

armstrong 发表于 2019-4-8 20:04

实测好用，500us变成了180us
今天做了一回伸手党

jlhgold

kinsno 发表于 2019-4-8 23:11
我找了半天，特地在找'f' ， 好象没找到。。是不是不支持浮点数。。

好像是没有看到‘f’

kinsno

tim4146 发表于 2019-4-9 17:23
实测好用，500us变成了180us
今天做了一回伸手党

浮点数呢？ 是不是你目前暂时用不上了，还是。。。

tim4146

kinsno 发表于 2019-4-9 19:18
浮点数呢？ 是不是你目前暂时用不上了，还是。。。

昨天只测了时间，阴差阳错忘记测数据了，然后今天发现所有的浮点数还有uint64类型数据出不来，已经全改好了，改了一下午……

kinsno

tim4146 发表于 2019-4-10 17:22
昨天只测了时间，阴差阳错忘记测数据了，然后今天发现所有的浮点数还有uint64类型数据出不来，已经全改好 ...

果然是没有浮点数的啊，看来我上面没有眼花啊。。
你修改后，带浮点数的版本，方便分亨一下吗。

icoyool

找gayhub，很多

huangqi412

写个精简的，去掉各种不要的东西。

tim4146

kinsno 发表于 2019-4-10 17:29
果然是没有浮点数的啊，看来我上面没有眼花啊。。
你修改后，带浮点数的版本，方便分亨一下吗。

下午写了但是公司代码加密了
说说思路，首先确定整形是可以用的，那么浮点数我就简单一点了，比如123.456需要保留3位小数，那就先乘以1000变成123456 然后当做int去处理了，过程中把小数点在千位前面加上就可以了

zhenhuajiang

简单好用就可以了，不必那么强大；

yanyanyan168

在github.com找到一个简化：

1. // mini-printf.h
   
2. #ifndef __MINI_PRINTF__
   
3. #define __MINI_PRINTF__
   
4. 
   
5. #ifdef __cplusplus
   
6. extern "C" {
   
7. #endif
   
8. 
   
9. #include <stdarg.h>
   
10. 
    
11. int mini_vsnprintf(char* buffer, unsigned int buffer_len, const char *fmt, va_list va);
    
12. int mini_snprintf(char* buffer, unsigned int buffer_len, const char *fmt, ...);
    
13. 
    
14. #ifdef __cplusplus
    
15. }
    
16. #endif
    
17. 
    
18. #define vsnprintf mini_vsnprintf
    
19. #define snprintf mini_snprintf
    
20. 
    
21. #endif
    

复制代码

1. #include "mini-printf.h"
   
2. 
   
3. static unsigned int
   
4. mini_strlen(const char *s)
   
5. {
   
6.         unsigned int len = 0;
   
7.         while (s[len] != '\0') len++;
   
8.         return len;
   
9. }
   
10. 
    
11. static unsigned int
    
12. mini_itoa(int value, unsigned int radix, unsigned int uppercase, unsigned int unsig,
    
13.          char *buffer, unsigned int zero_pad)
    
14. {
    
15.         char        *pbuffer = buffer;
    
16.         int        negative = 0;
    
17.         unsigned int        i, len;
    
18. 
    
19.         /* No support for unusual radixes. */
    
20.         if (radix > 16)
    
21.                 return 0;
    
22. 
    
23.         if (value < 0 && !unsig) {
    
24.                 negative = 1;
    
25.                 value = -value;
    
26.         }
    
27. 
    
28.         /* This builds the string back to front ... */
    
29.         do {
    
30.                 int digit = value % radix;
    
31.                 *(pbuffer++) = (digit < 10 ? '0' + digit : (uppercase ? 'A' : 'a') + digit - 10);
    
32.                 value /= radix;
    
33.         } while (value > 0);
    
34. 
    
35.         for (i = (pbuffer - buffer); i < zero_pad; i++)
    
36.                 *(pbuffer++) = '0';
    
37. 
    
38.         if (negative)
    
39.                 *(pbuffer++) = '-';
    
40. 
    
41.         *(pbuffer) = '\0';
    
42. 
    
43.         /* ... now we reverse it (could do it recursively but will
    
44.          * conserve the stack space) */
    
45.         len = (pbuffer - buffer);
    
46.         for (i = 0; i < len / 2; i++) {
    
47.                 char j = buffer[i];
    
48.                 buffer[i] = buffer[len-i-1];
    
49.                 buffer[len-i-1] = j;
    
50.         }
    
51. 
    
52.         return len;
    
53. }
    
54. 
    
55. struct mini_buff {
    
56.         char *buffer, *pbuffer;
    
57.         unsigned int buffer_len;
    
58. };
    
59. 
    
60. static int
    
61. _putc(int ch, struct mini_buff *b)
    
62. {
    
63.         if ((unsigned int)((b->pbuffer - b->buffer) + 1) >= b->buffer_len)
    
64.                 return 0;
    
65.         *(b->pbuffer++) = ch;
    
66.         *(b->pbuffer) = '\0';
    
67.         return 1;
    
68. }
    
69. 
    
70. static int
    
71. _puts(char *s, unsigned int len, struct mini_buff *b)
    
72. {
    
73.         unsigned int i;
    
74. 
    
75.         if (b->buffer_len - (b->pbuffer - b->buffer) - 1 < len)
    
76.                 len = b->buffer_len - (b->pbuffer - b->buffer) - 1;
    
77. 
    
78.         /* Copy to buffer */
    
79.         for (i = 0; i < len; i++)
    
80.                 *(b->pbuffer++) = s[i];
    
81.         *(b->pbuffer) = '\0';
    
82. 
    
83.         return len;
    
84. }
    
85. 
    
86. int
    
87. mini_vsnprintf(char *buffer, unsigned int buffer_len, const char *fmt, va_list va)
    
88. {
    
89.         struct mini_buff b;
    
90.         char bf[24];
    
91.         char ch;
    
92. 
    
93.         b.buffer = buffer;
    
94.         b.pbuffer = buffer;
    
95.         b.buffer_len = buffer_len;
    
96. 
    
97.         while ((ch=*(fmt++))) {
    
98.                 if ((unsigned int)((b.pbuffer - b.buffer) + 1) >= b.buffer_len)
    
99.                         break;
    
100.                 if (ch!='%')
     
101.                         _putc(ch, &b);
     
102.                 else {
     
103.                         char zero_pad = 0;
     
104.                         char *ptr;
     
105.                         unsigned int len;
     
106. 
     
107.                         ch=*(fmt++);
     
108. 
     
109.                         /* Zero padding requested */
     
110.                         if (ch=='0') {
     
111.                                 ch=*(fmt++);
     
112.                                 if (ch == '\0')
     
113.                                         goto end;
     
114.                                 if (ch >= '0' && ch <= '9')
     
115.                                         zero_pad = ch - '0';
     
116.                                 ch=*(fmt++);
     
117.                         }
     
118. 
     
119.                         switch (ch) {
     
120.                                 case 0:
     
121.                                         goto end;
     
122. 
     
123.                                 case 'u':
     
124.                                 case 'd':
     
125.                                         len = mini_itoa(va_arg(va, unsigned int), 10, 0, (ch=='u'), bf, zero_pad);
     
126.                                         _puts(bf, len, &b);
     
127.                                         break;
     
128. 
     
129.                                 case 'x':
     
130.                                 case 'X':
     
131.                                         len = mini_itoa(va_arg(va, unsigned int), 16, (ch=='X'), 1, bf, zero_pad);
     
132.                                         _puts(bf, len, &b);
     
133.                                         break;
     
134. 
     
135.                                 case 'c' :
     
136.                                         _putc((char)(va_arg(va, int)), &b);
     
137.                                         break;
     
138. 
     
139.                                 case 's' :
     
140.                                         ptr = va_arg(va, char*);
     
141.                                         _puts(ptr, mini_strlen(ptr), &b);
     
142.                                         break;
     
143. 
     
144.                                 default:
     
145.                                         _putc(ch, &b);
     
146.                                         break;
     
147.                         }
     
148.                 }
     
149.         }
     
150. end:
     
151.         return b.pbuffer - b.buffer;
     
152. }
     
153. 
     
154. 
     
155. int
     
156. mini_snprintf(char* buffer, unsigned int buffer_len, const char *fmt, ...)
     
157. {
     
158.         int ret;
     
159.         va_list va;
     
160.         va_start(va, fmt);
     
161.         ret = mini_vsnprintf(buffer, buffer_len, fmt, va);
     
162.         va_end(va);
     
163. 
     
164.         return ret;
     
165. }

复制代码

链接：https://github.com/mludvig/mini-printf

yanyanyan168

还有一个 可裁剪全功能小型 printf / sprintf
链接：https://github.com/mpaland/printf