有效地将 unsigned Short 转换为 char*

Question

将 unsigned Short 转换为 char* （即将 25 转换为 '25'）的有效、可移植的方法是什么？

我想避免诸如获取 (std::string) 字符串之类的事情。在这种情况下，性能很重要，因为这种转换需要快速且频繁地进行。

我正在研究诸如使用 sprintf 之类的事情，但想探索任何和所有的想法。

Answer 1

首先，正确地做，然后快速地做——只有当您可以确定地看到一段代码性能不佳时才进行优化。

snprintf() 放入缓冲区将执行您想要的操作。这是最快的解决方案吗？一点也不。但它是最简单的之一，足以让您的代码进入工作状态。从那里开始，如果您发现对 snprintf() 的调用非常费力，需要优化，那么只有这样才能寻求更快的解决方案。

Answer 2

一个字符串数组，

array[25] = "25";
array[26] = "26";

array[255] = "255";

也许？您可以编写一个小程序来非常轻松地生成表源代码，然后在您的项目中使用该文件。

编辑：我不明白你不想让字符串参与其中的意思。

Answer 3

试试这个：

int convert(unsigned short val, char* dest)
{
  int i = 0;
  if (val > 10000)
  {
    dest[i++] = (val / 10000) | 0x30;
    val %= 10000;
  }
  if (val > 1000)
  {
    dest[i++] = (val / 1000) | 0x30;
    val %= 1000;
  }
  if (val > 100)
  {
    dest[i++] = (val / 100) | 0x30;
    val %= 100;
  }
  if (val > 10)
  {
    dest[i++] = (val / 10) | 0x30;
    val %= 10;
  }
  dest[i++] = (val) | 0x30;
  dest[i] = 0;
  return i;
}

Answer 4

我想说至少尝试 sprintf 并且由于您已将其标记为 C++，请尝试 StringStream ，并实际分析它们。在许多情况下，编译器足够聪明，可以构建运行良好的东西。只有当您知道这将成为瓶颈时，您才需要真正找到更快的方法。

Answer 5

我在这里对各种功能进行了测试，这就是我得出的结果：

write_ushort: 7.81 s
uShortToStr：8.16 秒
转换：6.71 秒
use_sprintf: 49.66 s

（Write_ushort 是我的版本，我试图尽可能清楚地编写它，而不是进行微优化，以格式化为给定的字符缓冲区；use_sprintf 是明显的 sprintf(buf, "%d", x) 和没有别的；其他两个是从这里的其他答案中获取的。）

它们之间有一个非常惊人的区别，不是吗？面对几乎一个数量级的差异，谁会想到使用 sprintf 呢？哦，是的，我迭代了每个测试函数多少次？

// Taken directly from my hacked up test, but should be clear.
// Compiled with gcc 4.4.3 and -O2.  This test is interesting, but not authoritative.
int main() {
  using namespace std;
  char buf[100];

#define G2(NAME,STMT) \
  { \
    clock_t begin = clock(); \
    for (int count = 0; count < 3000; ++count) { \
      for (unsigned x = 0; x <= USHRT_MAX; ++x) { \
        NAME(x, buf, sizeof buf); \
      } \
    } \
    clock_t end = clock(); \
    STMT \
  }
#define G(NAME) G2(NAME,) G2(NAME,cout << #NAME ": " << double(end - begin) / CLOCKS_PER_SEC << " s\n";)
  G(write_ushort)
  G(uShortToStr)
  G(convert)
  G(use_sprintf)
#undef G
#undef G2

  return 0;
}

Sprintf 转换了整个可能范围的无符号短裤，然后在我大约 5 年的旧笔记本电脑上再次执行整个范围 2,999 次，平均每次转换大约 0.25 µs。

Sprintf 是可移植的；它是否也足够高效满足您的要求？

---

我的版本：

// Returns number of non-null bytes written, or would be written.
// If ret is null, does not write anything; otherwise retlen is the length of
// ret, and must include space for the number plus a terminating null.
int write_ushort(unsigned short x, char *ret, int retlen) {
  assert(!ret || retlen >= 1);

  char s[uint_width_10<USHRT_MAX>::value];  // easy implementation agnosticism
  char *n = s;
  if (x == 0) {
    *n++ = '0';
  }
  else while (x != 0) {
    *n++ = '0' + x % 10;
    x /= 10;
  }

  int const digits = n - s;
  if (ret) {
    // not needed by checking retlen and only writing to available space
    //assert(retlen >= digits + 1);

    while (--retlen && n != s) {
      *ret++ = *--n;
    }
    *ret = '\0';
  }
  return digits;
}

编译时日志 TMP 函数并不是什么新鲜事，但包括这个完整的示例，因为它是我使用的：

template<unsigned N>
struct uint_width_10_nonzero {
  enum { value = uint_width_10_nonzero<N/10>::value + 1 };
};
template<>
struct uint_width_10_nonzero<0> {
  enum { value = 0 };
};
template<unsigned N>
struct uint_width_10 {
  enum { value = uint_width_10_nonzero<N>::value };
};
template<>
struct uint_width_10<0> {
  enum { value = 1 };
};