itoa整数转字符串

已于 2023-04-23 14:39:17 修改
阅读量71 收藏 1
点赞数
分类专栏： C语言学习 文章标签： c语言 开发语言
于 2023-04-23 14:38:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhxonmir2/article/details/130321035
版权

之前我也写了个itoa只比库函数的itoa快一点点, 最近QQ上看到有位同学写了个i2a,声称是世界上最快的, 我下了代码跑了一下的确是比我的那个方法快了很多,不过没过多久,又有位同学跳出来打脸了, 他用jeaiii跟i2a对比了一下, 快了50%+, 这里贴一下jeaiii的代码:

/*

MIT License

Copyright (c) 2022 James Edward Anhalt III - https://github.com/jeaiii/itoa

Permission is hereby granted, free of charge, to any person obtaining a copy

of this software and associated documentation files (the "Software"), to deal

in the Software without restriction, including without limitation the rights

to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

copies of the Software, and to permit persons to whom the Software is

furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all

copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

SOFTWARE.

*/

#ifndef JEAIII_TO_TEXT_H_

#define JEAIII_TO_TEXT_H_

namespace jeaiii

{

using u32 = decltype(0xffffffff);

using u64 = decltype(0xffffffffffffffff);

struct pair

{

char dd[2];

constexpr pair(char c) : dd{ c, '\0' } { }

constexpr pair(int n) : dd{ "0123456789"[n / 10], "0123456789"[n % 10] } { }

};

constexpr struct

{

pair dd[100]

{

0, 1, 2, 3, 4, 5, 6, 7, 8, 9,

10, 11, 12, 13, 14, 15, 16, 17, 18, 19,

20, 21, 22, 23, 24, 25, 26, 27, 28, 29,

30, 31, 32, 33, 34, 35, 36, 37, 38, 39,

40, 41, 42, 43, 44, 45, 46, 47, 48, 49,

50, 51, 52, 53, 54, 55, 56, 57, 58, 59,

60, 61, 62, 63, 64, 65, 66, 67, 68, 69,

70, 71, 72, 73, 74, 75, 76, 77, 78, 79,

80, 81, 82, 83, 84, 85, 86, 87, 88, 89,

90, 91, 92, 93, 94, 95, 96, 97, 98, 99,

};

pair fd[100]

{

'0','1','2','3','4','5','6','7','8','9',

10, 11, 12, 13, 14, 15, 16, 17, 18, 19,

20, 21, 22, 23, 24, 25, 26, 27, 28, 29,

30, 31, 32, 33, 34, 35, 36, 37, 38, 39,

40, 41, 42, 43, 44, 45, 46, 47, 48, 49,

50, 51, 52, 53, 54, 55, 56, 57, 58, 59,

60, 61, 62, 63, 64, 65, 66, 67, 68, 69,

70, 71, 72, 73, 74, 75, 76, 77, 78, 79,

80, 81, 82, 83, 84, 85, 86, 87, 88, 89,

90, 91, 92, 93, 94, 95, 96, 97, 98, 99,

};

}

digits;

constexpr u64 mask24 = (u64(1) << 24) - 1;

constexpr u64 mask32 = (u64(1) << 32) - 1;

constexpr u64 mask57 = (u64(1) << 57) - 1;

template<bool, class, class F> struct _cond { using type = F; };

template<class T, class F> struct _cond<true, T, F> { using type = T; };

template<bool B, class T, class F> using cond = typename _cond<B, T, F>::type;

template<class T>

#if defined(_MSC_VER)

__forceinline

#else

inline

#endif

char* to_text_from_integer(char* b, T i)

{

constexpr auto q = sizeof(T);

using U = cond<q == 1, unsigned char, cond<q <= sizeof(short), unsigned short, cond<q <= sizeof(u32), u32, u64>>>;

// convert bool to int before test with unary + to silence warning if T happens to be bool

U const n = +i < 0 ? *b++ = '-', U(0) - U(i) : U(i);

if (n < u32(1e2))

{

*reinterpret_cast<pair*>(b) = digits.fd[n];

return n < 10 ? b + 1 : b + 2;

}

if (n < u32(1e6))

{

if (n < u32(1e4))

{

auto f0 = u32(10 * (1 << 24) / 1e3 + 1) * n;

*reinterpret_cast<pair*>(b) = digits.fd[f0 >> 24];

b -= n < u32(1e3);

auto f2 = (f0 & mask24) * 100;

*reinterpret_cast<pair*>(b + 2) = digits.dd[f2 >> 24];

return b + 4;

}

auto f0 = u64(10 * (1ull << 32ull)/ 1e5 + 1) * n;

*reinterpret_cast<pair*>(b) = digits.fd[f0 >> 32];

b -= n < u32(1e5);

auto f2 = (f0 & mask32) * 100;

*reinterpret_cast<pair*>(b + 2) = digits.dd[f2 >> 32];

auto f4 = (f2 & mask32) * 100;

*reinterpret_cast<pair*>(b + 4) = digits.dd[f4 >> 32];

return b + 6;

}

if (n < u64(1ull << 32ull))

{

if (n < u32(1e8))

{

auto f0 = u64(10 * (1ull << 48ull) / 1e7 + 1) * n >> 16;

*reinterpret_cast<pair*>(b) = digits.fd[f0 >> 32];

b -= n < u32(1e7);

auto f2 = (f0 & mask32) * 100;

*reinterpret_cast<pair*>(b + 2) = digits.dd[f2 >> 32];

auto f4 = (f2 & mask32) * 100;

*reinterpret_cast<pair*>(b + 4) = digits.dd[f4 >> 32];

auto f6 = (f4 & mask32) * 100;

*reinterpret_cast<pair*>(b + 6) = digits.dd[f6 >> 32];

return b + 8;

}

auto f0 = u64(10 * (1ull << 57ull) / 1e9 + 1) * n;

*reinterpret_cast<pair*>(b) = digits.fd[f0 >> 57];

b -= n < u32(1e9);

auto f2 = (f0 & mask57) * 100;

*reinterpret_cast<pair*>(b + 2) = digits.dd[f2 >> 57];

auto f4 = (f2 & mask57) * 100;

*reinterpret_cast<pair*>(b + 4) = digits.dd[f4 >> 57];

auto f6 = (f4 & mask57) * 100;

*reinterpret_cast<pair*>(b + 6) = digits.dd[f6 >> 57];

auto f8 = (f6 & mask57) * 100;

*reinterpret_cast<pair*>(b + 8) = digits.dd[f8 >> 57];

return b + 10;

}

// if we get here U must be u64 but some compilers don't know that, so reassign n to a u64 to avoid warnings

u32 z = n % u32(1e8);

u64 u = n / u32(1e8);

if (u < u32(1e2))

{

// u can't be 1 digit (if u < 10 it would have been handled above as a 9 digit 32bit number)

*reinterpret_cast<pair*>(b) = digits.dd[u];

b += 2;

}

else if (u < u32(1e6))

{

if (u < u32(1e4))

{

auto f0 = u32(10 * (1 << 24) / 1e3 + 1) * u;

*reinterpret_cast<pair*>(b) = digits.fd[f0 >> 24];

b -= u < u32(1e3);

auto f2 = (f0 & mask24) * 100;

*reinterpret_cast<pair*>(b + 2) = digits.dd[f2 >> 24];

b += 4;

}

else

{

auto f0 = u64(10 * (1ull << 32ull) / 1e5 + 1) * u;

*reinterpret_cast<pair*>(b) = digits.fd[f0 >> 32];

b -= u < u32(1e5);

auto f2 = (f0 & mask32) * 100;

*reinterpret_cast<pair*>(b + 2) = digits.dd[f2 >> 32];

auto f4 = (f2 & mask32) * 100;

*reinterpret_cast<pair*>(b + 4) = digits.dd[f4 >> 32];

b += 6;

}

}

else if (u < u32(1e8))

{

auto f0 = u64(10 * (1ull << 48ull) / 1e7 + 1) * u >> 16;

*reinterpret_cast<pair*>(b) = digits.fd[f0 >> 32];

b -= u < u32(1e7);

auto f2 = (f0 & mask32) * 100;

*reinterpret_cast<pair*>(b + 2) = digits.dd[f2 >> 32];

auto f4 = (f2 & mask32) * 100;

*reinterpret_cast<pair*>(b + 4) = digits.dd[f4 >> 32];

auto f6 = (f4 & mask32) * 100;

*reinterpret_cast<pair*>(b + 6) = digits.dd[f6 >> 32];

b += 8;

}

else if (u < u64(1ull << 32ull))

{

auto f0 = u64(10 * (1ull << 57ull) / 1e9 + 1) * u;

*reinterpret_cast<pair*>(b) = digits.fd[f0 >> 57];

b -= u < u32(1e9);

auto f2 = (f0 & mask57) * 100;

*reinterpret_cast<pair*>(b + 2) = digits.dd[f2 >> 57];

auto f4 = (f2 & mask57) * 100;

*reinterpret_cast<pair*>(b + 4) = digits.dd[f4 >> 57];

auto f6 = (f4 & mask57) * 100;

*reinterpret_cast<pair*>(b + 6) = digits.dd[f6 >> 57];

auto f8 = (f6 & mask57) * 100;

*reinterpret_cast<pair*>(b + 8) = digits.dd[f8 >> 57];

b += 10;

}

else

{

u32 y = u % u32(1e8);

u /= u32(1e8);

// u is 2, 3, or 4 digits (if u < 10 it would have been handled above)

if (u < u32(1e2))

{

*reinterpret_cast<pair*>(b) = digits.dd[u];

b += 2;

}

else

{

auto f0 = u32(10 * (1 << 24) / 1e3 + 1) * u;

*reinterpret_cast<pair*>(b) = digits.fd[f0 >> 24];

b -= u < u32(1e3);

auto f2 = (f0 & mask24) * 100;

*reinterpret_cast<pair*>(b + 2) = digits.dd[f2 >> 24];

b += 4;

}

// do 8 digits

auto f0 = (u64((1ull << 48ull) / 1e6 + 1) * y >> 16) + 1;

*reinterpret_cast<pair*>(b) = digits.dd[f0 >> 32];

auto f2 = (f0 & mask32) * 100;

*reinterpret_cast<pair*>(b + 2) = digits.dd[f2 >> 32];

auto f4 = (f2 & mask32) * 100;

*reinterpret_cast<pair*>(b + 4) = digits.dd[f4 >> 32];

auto f6 = (f4 & mask32) * 100;

*reinterpret_cast<pair*>(b + 6) = digits.dd[f6 >> 32];

b += 8;

}

// do 8 digits

auto f0 = (u64((1ull << 48ull) / 1e6 + 1) * z >> 16) + 1;

*reinterpret_cast<pair*>(b) = digits.dd[f0 >> 32];

auto f2 = (f0 & mask32) * 100;

*reinterpret_cast<pair*>(b + 2) = digits.dd[f2 >> 32];

auto f4 = (f2 & mask32) * 100;

*reinterpret_cast<pair*>(b + 4) = digits.dd[f4 >> 32];

auto f6 = (f4 & mask32) * 100;

*reinterpret_cast<pair*>(b + 6) = digits.dd[f6 >> 32];

return b + 8;

}

}

#endif // JEAIII_TO_TEXT_H_

但是这个是C++写的, 而且还要比较高版本的C++才能编译, 我就用C改写了一下:

const char* fd =

"0010203040506070809010111213141516171819202122232425262728293031323334353637383940414243444546474849"

"5051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899";

const char* dd =

"0001020304050607080910111213141516171819202122232425262728293031323334353637383940414243444546474849"

"5051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899";

typedef unsigned int u32;

typedef unsigned __int64 u64;

const u64 mask24 = (u64(1) << 24) - 1;

const u64 mask32 = (u64(1) << 32) - 1;

const u64 mask57 = (u64(1) << 57) - 1;

char* zutoac(char* b, unsigned int n)

{

if (n < 100)

{

*(short*)b = *(short*)&fd[n << 1];

return n < 10 ? b + 1 : b + 2;

}

if (n < u32(1000000))

{

if (n < u32(10000))

{

auto f0 = u32(10 * (1 << 24) / 1000 + 1) * n;

*(short*)b = *(short*)&fd[(f0 >> 24) << 1];

b -= n < u32(1000);

auto f2 = (f0 & mask24) * 100;

*(short*)(b + 2) = *(short*)&dd[(f2 >> 24) << 1];

return b + 4;

}

auto f0 = u64(10 * (1ull << 32ull) / 100000 + 1) * n;

*(short*)b = *(short*)&fd[(f0 >> 32) << 1];

b -= n < u32(100000);

auto f2 = (f0 & mask32) * 100;

*(short*)(b + 2) = *(short*)&dd[(f2 >> 32) << 1];

auto f4 = (f2 & mask32) * 100;

*(short*)(b + 4) = *(short*)&dd[(f4 >> 32) << 1];

return b + 6;

}

if (n < u32(100000000))

{

auto f0 = u64(10 * (1ull << 48ull) / 10000000 + 1) * n >> 16;

*(short*)b = *(short*)&fd[(f0 >> 32) << 1];

b -= n < u32(10000000);

auto f2 = (f0 & mask32) * 100;

*(short*)(b + 2) = *(short*)&dd[(f2 >> 32) << 1];

auto f4 = (f2 & mask32) * 100;

*(short*)(b + 4) = *(short*)&dd[(f4 >> 32) << 1];

auto f6 = (f4 & mask32) * 100;

*(short*)(b + 6) = *(short*)&dd[(f6 >> 32) << 1];

return b + 8;

}

auto f0 = u64(10 * (1ull << 57ull) / 1000000000 + 1) * n;

*(short*)b = *(short*)&fd[(f0 >> 57) << 1];

b -= n < u32(1000000000);

auto f2 = (f0 & mask57) * 100;

*(short*)(b + 2) = *(short*)&dd[(f2 >> 57) << 1];

auto f4 = (f2 & mask57) * 100;

*(short*)(b + 4) = *(short*)&dd[(f4 >> 57) << 1];

auto f6 = (f4 & mask57) * 100;

*(short*)(b + 6) = *(short*)&dd[(f6 >> 57) << 1];

auto f8 = (f6 & mask57) * 100;

*(short*)(b + 8) = *(short*)&dd[(f8 >> 57) << 1];

return b + 10;

}

char* zitoac(char* b, int i, bool connect)

{

const int n = +i < 0 ? *b++ = '-', 0 - i : i;

if (n < 100)

{

*(short*)b = *(short*)&fd[n << 1];

return n < 10 ? b + 1 : b + 2;

}

if (n < u32(1000000))

{

if (n < u32(10000))

{

auto f0 = u32(10 * (1 << 24) / 1000 + 1) * n;

*(short*)b = *(short*)&fd[(f0 >> 24) << 1];

b -= n < u32(1000);

auto f2 = (f0 & mask24) * 100;

*(short*)(b + 2) = *(short*)&dd[(f2 >> 24) << 1];

return b + 4;

}

auto f0 = u64(10 * (1ull << 32ull) / 100000 + 1) * n;

*(short*)b = *(short*)&fd[(f0 >> 32) << 1];

b -= n < u32(100000);

auto f2 = (f0 & mask32) * 100;

*(short*)(b + 2) = *(short*)&dd[(f2 >> 32) << 1];

auto f4 = (f2 & mask32) * 100;

*(short*)(b + 4) = *(short*)&dd[(f4 >> 32) << 1];

return b + 6;

}

if (n < u32(100000000))

{

auto f0 = u64(10 * (1ull << 48ull) / 10000000 + 1) * n >> 16;

*(short*)b = *(short*)&fd[(f0 >> 32) << 1];

b -= n < u32(10000000);

auto f2 = (f0 & mask32) * 100;

*(short*)(b + 2) = *(short*)&dd[(f2 >> 32) << 1];

auto f4 = (f2 & mask32) * 100;

*(short*)(b + 4) = *(short*)&dd[(f4 >> 32) << 1];

auto f6 = (f4 & mask32) * 100;

*(short*)(b + 6) = *(short*)&dd[(f6 >> 32) << 1];

return b + 8;

}

auto f0 = u64(10 * (1ull << 57ull) / 1000000000 + 1) * n;

*(short*)b = *(short*)&fd[(f0 >> 57) << 1];

b -= n < u32(1000000000);

auto f2 = (f0 & mask57) * 100;

*(short*)(b + 2) = *(short*)&dd[(f2 >> 57) << 1];

auto f4 = (f2 & mask57) * 100;

*(short*)(b + 4) = *(short*)&dd[(f4 >> 57) << 1];

auto f6 = (f4 & mask57) * 100;

*(short*)(b + 6) = *(short*)&dd[(f6 >> 57) << 1];

auto f8 = (f6 & mask57) * 100;

*(short*)(b + 8) = *(short*)&dd[(f8 >> 57) << 1];

return b + 10;

}

char* zutoa(char* b, unsigned int n)

{

if (n < 100)

{

*(short*)b = *(short*)&fd[n << 1];

if (n < 10)

b[1] = 0;

else

b[2] = 0;

return b;

}

if (n < u32(1000000))

{

if (n < u32(10000))

{

auto f0 = u32(10 * (1 << 24) / 1000 + 1) * n;

*(short*)b = *(short*)&fd[(f0 >> 24) << 1];

b -= n < u32(1000);

auto f2 = (f0 & mask24) * 100;

*(short*)(b + 2) = *(short*)&dd[(f2 >> 24) << 1];

b[4]=0;

return b;

}

auto f0 = u64(10 * (1ull << 32ull) / 100000 + 1) * n;

*(short*)b = *(short*)&fd[(f0 >> 32) << 1];

b -= n < u32(100000);

auto f2 = (f0 & mask32) * 100;

*(short*)(b + 2) = *(short*)&dd[(f2 >> 32) << 1];

auto f4 = (f2 & mask32) * 100;

*(short*)(b + 4) = *(short*)&dd[(f4 >> 32) << 1];

b[6] = 0;

return b;

}

if (n < u32(100000000))

{

auto f0 = u64(10 * (1ull << 48ull) / 10000000 + 1) * n >> 16;

*(short*)b = *(short*)&fd[(f0 >> 32) << 1];

b -= n < u32(10000000);

auto f2 = (f0 & mask32) * 100;

*(short*)(b + 2) = *(short*)&dd[(f2 >> 32) << 1];

auto f4 = (f2 & mask32) * 100;

*(short*)(b + 4) = *(short*)&dd[(f4 >> 32) << 1];

auto f6 = (f4 & mask32) * 100;

*(short*)(b + 6) = *(short*)&dd[(f6 >> 32) << 1];

b[8] = 0;

return b;

}

auto f0 = u64(10 * (1ull << 57ull) / 1000000000 + 1) * n;

*(short*)b = *(short*)&fd[(f0 >> 57) << 1];

b -= n < u32(1000000000);

auto f2 = (f0 & mask57) * 100;

*(short*)(b + 2) = *(short*)&dd[(f2 >> 57) << 1];

auto f4 = (f2 & mask57) * 100;

*(short*)(b + 4) = *(short*)&dd[(f4 >> 57) << 1];

auto f6 = (f4 & mask57) * 100;

*(short*)(b + 6) = *(short*)&dd[(f6 >> 57) << 1];

auto f8 = (f6 & mask57) * 100;

*(short*)(b + 8) = *(short*)&dd[(f8 >> 57) << 1];

b[10] = 0;

return b;

}

char* zitoa(char* b, int i, bool connect)

{

const int n = +i < 0 ? *b++ = '-', 0 - i : i;

if (n < 100)

{

*(short*)b = *(short*)&fd[n << 1];

if (n < 10)

b[1] = 0;

else

b[2] = 0;

return b;

}

if (n < u32(1000000))

{

if (n < u32(10000))

{

auto f0 = u32(10 * (1 << 24) / 1000 + 1) * n;

*(short*)b = *(short*)&fd[(f0 >> 24) << 1];

b -= n < u32(1000);

auto f2 = (f0 & mask24) * 100;

*(short*)(b + 2) = *(short*)&dd[(f2 >> 24) << 1];

b[4] = 0;

return b;

}

auto f0 = u64(10 * (1ull << 32ull) / 100000 + 1) * n;

*(short*)b = *(short*)&fd[(f0 >> 32) << 1];

b -= n < u32(100000);

auto f2 = (f0 & mask32) * 100;

*(short*)(b + 2) = *(short*)&dd[(f2 >> 32) << 1];

auto f4 = (f2 & mask32) * 100;

*(short*)(b + 4) = *(short*)&dd[(f4 >> 32) << 1];

b[6] = 0;

return b;

}

if (n < u32(100000000))

{

auto f0 = u64(10 * (1ull << 48ull) / 10000000 + 1) * n >> 16;

*(short*)b = *(short*)&fd[(f0 >> 32) << 1];

b -= n < u32(10000000);

auto f2 = (f0 & mask32) * 100;

*(short*)(b + 2) = *(short*)&dd[(f2 >> 32) << 1];

auto f4 = (f2 & mask32) * 100;

*(short*)(b + 4) = *(short*)&dd[(f4 >> 32) << 1];

auto f6 = (f4 & mask32) * 100;

*(short*)(b + 6) = *(short*)&dd[(f6 >> 32) << 1];

b[8] = 0;

return b;

}

auto f0 = u64(10 * (1ull << 57ull) / 1000000000 + 1) * n;

*(short*)b = *(short*)&fd[(f0 >> 57) << 1];

b -= n < u32(1000000000);

auto f2 = (f0 & mask57) * 100;

*(short*)(b + 2) = *(short*)&dd[(f2 >> 57) << 1];

auto f4 = (f2 & mask57) * 100;

*(short*)(b + 4) = *(short*)&dd[(f4 >> 57) << 1];

auto f6 = (f4 & mask57) * 100;

*(short*)(b + 6) = *(short*)&dd[(f6 >> 57) << 1];

auto f8 = (f6 & mask57) * 100;

*(short*)(b + 8) = *(short*)&dd[(f8 >> 57) << 1];

b[10] = 0;

return b;

}

运行测试 VS2022-Release:

#define COUNT 10000000

int main()

{

char buff[32] = { 0 };

DWORD dw = -8888888;

volatile char* p = NULL;

DWORD64 start, end;

start = __rdtsc();

for (size_t i = 0; i < COUNT; i++)

sprintf_s(buff, "%u", dw);

end = __rdtsc();

printf("%12I64u:%s\n", end - start, buff);

start = __rdtsc();

for (size_t i = 0; i < COUNT; i++)

p = zutoa(buff, dw);

end = __rdtsc();

printf("%12I64u:%s\n", end - start, buff);

start = __rdtsc();

for (size_t i = 0; i < COUNT; i++)

p = jeaiii::to_text_from_integer(buff, dw);

end = __rdtsc();

printf("%12I64u:%s\n", end - start, buff);

start = __rdtsc();

for (size_t i = 0; i < COUNT; i++)

*p = u2a(buff, dw);

end = __rdtsc();

printf("%12I64u:%s\n", end - start, buff);

return 0;

}

1908865185:4286078408          //sprintf("%d"

    20285761:4286078408          //jeaiii C版本

    20611648:4286078408          //jeaiii C++

 144759284:4286078408          //这就是那位写的说是世界上最快的itoa,也就比sprintf快十来倍

GCC测试结果:

#include "i2a.h"

#include <sys/time.h>

#define COUNT 10000000

int main()

{

char buff[32] = { 0 };

volatile unsigned int dw = -8888888;

volatile char* p = NULL;

struct timeval start, end, result;

gettimeofday(&start, NULL);

for (size_t i = 0; i < COUNT; i++)

sprintf(buff, "%u", dw);

gettimeofday(&end, NULL);

timersub(&end, &start, &result);

printf("%10.4lf:%s\n", result.tv_sec * 1000.0 + result.tv_usec / 1000.0, buff);

gettimeofday(&start, NULL);

for (size_t i = 0; i < COUNT; i++)

p = zutoa(buff, dw);

gettimeofday(&end, NULL);

timersub(&end, &start, &result);

printf("%10.4lf:%s\n", result.tv_sec * 1000.0 + result.tv_usec / 1000.0, buff);

gettimeofday(&start, NULL);

for (size_t i = 0; i < COUNT; i++)

p = jeaiii::to_text_from_integer(buff, dw);

gettimeofday(&end, NULL);

timersub(&end, &start, &result);

printf("%10.4lf:%s\n", result.tv_sec * 1000.0 + result.tv_usec / 1000.0, buff);

gettimeofday(&start, NULL);

for (size_t i = 0; i < COUNT; i++)

*p = u2a(buff, dw);

gettimeofday(&end, NULL);

timersub(&end, &start, &result);

printf("%10.4lf:%s\n", result.tv_sec * 1000.0 + result.tv_usec / 1000.0, buff);

return 0;

}

363.3760:4286078408

20.9070:4286078408

22.6350:4286078408

36.2540:4286078408

zhxonmir2
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux c数字转字符串函数,C 语言整数与字符串的相互转换介绍
weixin_42358539的博客
04-29 1787
导读C 语言中整数与字符串的相互转换，有广泛应用的拓展函数(非标准库)，也可以自己尝试简单的实现。一、简述C 语言中整数与字符串的相互转换，有广泛应用的拓展函数(非标准库)，也可以自己尝试简单的实现。二、整数转字符串1、拓展函数 itoaitoa (表示 integer to alphanumeric)是把整型数转换成字符串的一个函数。windows 环境下，在 头文件中有:char* itoa(...
c 语言整形转换为字符串,C 语言整数与字符串的相互转换
weixin_42306055的博客
05-18 9659
一、简述C 语言中整数与字符串的相互转换，有广泛应用的拓展函数(非标准库)，也可以自己尝试简单的实现。二、整数转字符串1、拓展函数 itoaitoa (表示 integer to alphanumeric)是把整型数转换成字符串的一个函数。windows 环境下，在 头文件中有:char* itoa(int value,char*string,int radix);//value: 要转换的整数...
C语言 整数与字符串的相互转换
热门推荐
Genven_Liang的博客
06-26 14万+
C语言 整数与字符串的相互转换 一、简述 C语言中整数与字符串的相互转换，有广泛应用的拓展函数(非标准库)，也可以自己尝试简单的实现。 二、整数转字符串 1、拓展函数itoa itoa (表示 integer to alphanumeric)是把整型数转换成字符串的一个函数。 windows环境下，在&lt;stdlib.h&gt;头文件中有 c...
C语言整数转字符串itoa
板蓝根蜀黍的博客
09-19 1239
/* 整型数字转字符(包括负数)  */ #include #include /* 判断这个数字是几位数  */ int num_length(int num)   { int length=0; if(num { num*=-1; while(num) { num=num/10; length++; } return length+1; }
C++中整数转字符串的几种方法
Lacon的BOKO
09-08 4万+
源头：http://www.cnblogs.com/hujunzheng/p/5042068.html 方法一 使用ANSI C 中的sprintf();和sscanf();函数。 格式化符号 %%打印出%符号不进行转换。 %c 整数转成对应的 ASCII 字元。 %d 整数转成十进位。 %f 倍精确度数字转成浮点数。 %o 整数转成八进位。 %s 整数转成字符串。 %x 整数...
整数转字符串的C语言实现
只手阳光的博客
01-02 5905
算法思路： 逆序将整数单个位数转换成字符赋值进入数组，此时得到一个逆序的字符串数组，最后要加’\0’结束符； 输出时逆序输出，或者逆置字符串数组再输出也可以得到结果； #include<stdio.h> #include<string.h> void itoa(int num, char str[100]) { int i = 0; do { str[i] = num % 10 + '0'; num /= 10; i++; } while (num); str
字符串整数之间的转换
SANsanSAN_的博客
03-15 3952
在数字和字符之间转换 一、整数转字符 1.在后面加’0‘即可，如：‘1’+‘0’ 这样做可行是因为字符0到字符9在ascii编码时是连续的，字符0的ascii值是48，字符1的ascii值是49，其他数字字符依次往后排，而ascii值实际上就是char型整数，所以可以用两个字符相加得到结果。 2.强制转换类型。 int a=9; char b; b=(char)a; printf("%c",b); 二、字符转整数 1.在后面减去‘0’，用数字字付出减去’0’即’1’-‘0’(它俩是用ASCI
数字转字符串c语言itoa,数字转换为对应的字符串，itoa
weixin_36347133的博客
05-17 345
实现一个函数itoa(int n,char s[])，将整数n这个数字转换为对应的字符串，保存到s中#include#includevoidmy_itoa(chararr[],intn)//数字转换为对应的字符串{inti=0;intstart=0;intend=0;while(n){arr[i]=(n%10)+'0';n=n/10;i++;}end=...
【C++常用函数】整数转字符串itoa()
程序猿进化梯
09-06 1万+
itoa() #include <iostream>//输入输出 #include <stdlib.h>//atoi函数 using namespace std; const int N = 100010; void main() { int a; cin >> a; char s[10]; itoa(a, s, 10); cout << s << endl; } 错误 C4996 ‘itoa’: The POSIX name.
stm32 整数转字符串,浮点数转字符串
qq_37131451的博客
12-16 4832
整数转字符串 char *reverse(char *s) { char temp; char *p = s; //p指向s的头部 char *q = s; //q指向s的尾部 while(*q) ++q; q--; //交换移动指针，直到p和q交叉 while(q > p) { temp = *p; *p++ = *q; *q-- = temp; }
itoa：快速整数到ASCII整数到字符串的转换
02-05
itoa：快速整数到ASCII整数到字符串的转换
Go语言整数值转字符串的效率问题
01-20
标准库提供了三种方法可以将整数值转为字符串。 fmt.Sprintf strconv.FormatInt strconv.Itoa 运行下面的代码，可以得到三种方法的基础测试结果。 package test import ( fmt strconv testing ) func ...
itoa-benchmark, C 整数到字符串转换基准.zip
09-18
itoa-benchmark, C 整数到字符串转换基准 itoa基准测试Copyright(c) 2014 -2016 ( [email protected] )简介这个基准评估从 32 -bit/64位 整数转换为十进制字符串的性能。 函数Prototype包括：void u32
c语言的itoa,浮点,int整数转换为字符串,整型转十六进制字符,兼容单片机STM等C开发用
09-22
c语言的itoa：char *m_itoa(int n) 整数转换为字符串。char *m_itoh(unsigned int num, int length, int prefix)整数转换为0x十六进制字符串。num: 要转换的数字,无视符号。length:指定字节长度,一字节为2个十六进制...
C语言itoa()函数和atoi()函数详解(整数转字符)
08-19
C语言提供了几个标准库函数，可以将任意类型(整型、长整型、浮点型等)的数字转换为字符串。
C语言——模拟实现库函数atoi
2302_80250536的博客
05-13 400
INT_MAX 和 INT_MIN 是 C语言 的两个预定义宏，代表了整型变量能够存储的最大正整数21474836472^31 − 1）和最小负整数-2^31这个值是相对于二进制补码表示的，也就是说，负数的范围比正数大 1,这两个宏在头文件中定义。
C语言：设计循环队列
Another_Shi的博客
05-18 754
本篇博客是写完LeetCode_662.设计循环队列之后有感而发，于是写下了一些思路和总结。本题用了两种方法来解答——顺序表和链表。
从需求角度介绍PasteSpider(K8S平替部署工具适合于任何开发语言)
05-14 1098
Kubernetes的强大毋庸置疑，但是你有问自己这么个大杀器真的适合你么？这里推荐一款更加小巧的容器部署工具，集报表，发布，环境，通知于一身的PasteSpider! 支持git/svn发布，支持平滑升级，支持环境隔离，支持用户隔离，支持运行变量设定等，关键易上手！
钢桁架结构振动特性渐变分析工具
最新发布
05-20
钢桁架结构振动特性渐变分析工具
go语言 整数转字符串
05-09
在 Go 语言中，可以使用 strconv 包中的 Itoa 函数将整数转换为字符串。示例代码如下： ```go package main import ( "fmt" "strconv" ) func main() { i := 123 s := strconv.Itoa(i) fmt.Println(s) } ``` 输出结果为： ``` 123 ``` 如果需要指定进制，可以使用 FormatInt 或 FormatUint 函数。例如，将十进制的 123 转换为二进制字符串： ```go package main import ( "fmt" "strconv" ) func main() { i := 123 s := strconv.FormatInt(int64(i), 2) fmt.Println(s) } ``` 输出结果为： ``` 1111011 ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值