二进制转换中的十六进制与十进制

Question

例如，这里有两种设置整数变量的方法（比如 C++）：

int x = 0xFF;
int y = 255;

哪种语句编译速度更快，可以将实际位设置为整数值？

编辑：*编译从执行更改。我假设转换为二进制文件是在执行时，但鉴于 @muntoo 的回答，似乎是在编译时

Answer 1

执行时间绝对没有差异，编译速度也可能没有差异。

添加以回复评论：
事情是这样的。编译器有一个解析器，可能是递归下降的，并且在底部调用词法分析器来获取标记。在这种情况下，=之后的标记是一个数字，它可以通过前导数字来判断，所以它是这样的，其中pc是指向当前字符的指针：

if (isdigit(*pc)){
  intpart = 0;
  if (pc[0]=='0' && pc[1]=='x'){
    pc += 2;
    while(ishexdigit(*pc)){
      intpart *= 16;
      if (isdigit(*pc)){
        intpart += (*pc - '0')
      }
      else {
        intpart += (tolower(*pc) - 'a' + 10);
      }
      pc++;
    }
  }
  else {
    while(isdigit(*pc)){
      intpart *= 10;
      intpart += (*pc - '0');
      pc++;
    }
    if (*pc == '.'){
      // ... handle fractional part
    }
  }
}

无论如何，正如您所看到的，这是一个非常紧密的循环，对数字中的每个字符执行一次或两次 isdigit 或 ishexdigit 或 tolower 操作，以及乘法、减法和加法。假设这些函数是内联的，我们所说的每个字符可能有 10-20 个指令。
在十六进制情况下，每个字符的指令可能会稍微多一些，但十进制数会有更多的字符，因此很难判断哪个应该更快。
这种情况只发生在您有能力在代码中输入的此类整数总数时，例如大约 100 个。
如果机器每秒可以执行 10^8 条指令，那么它可以以每秒大约 10^7 的速度读取数字，或者每个字符大约 100 纳秒，或者文件中所有数字的读取时间为 10 微秒，给出或取一个数量级。

一旦编译器知道它是一个数字，它就成为抽象语法树的一部分，用于生成汇编语言。到那时，它是十六进制或十进制的事实早已被遗忘。它只知道它是某个值的二进制整数，因此汇编语言将是相同的。

Answer 2

从编译器的角度来看，0xFF 与 255 相同。两者都会生成完全相同的代码。您的编译器将它们都“转换”为 11111111b。

---

编译速度完全取决于编译器及其编译方式。

例如，0xFF 可以被识别为十六进制数字（忽略正则表达式，这将是首选方法）：

bool myishex(string sz)
{
    if(sz[0] == '0' && sz[1] == 'x')
    {
        for(size_t i = 2; i < sz.length(); ++i)
            if(!(sz[i] >= '0' && sz[i] <= '9') || !(sz[i] >= 'A' && sz[i] <= 'F') || !(sz[i] >= 'a' && sz[i] <= 'f'))
                return(false);
    }
    else
    {
        return(false);
    }

    return(true);
}

与 myisnum() 相比：

bool myisnum(string sz)
{
    for(size_t i = 0; i < sz.length(); ++i)
        if(!(sz[i] >= '0' && sz[i] <= '9'))
            return(false);

    return(true);
}

嗯，myisnum()通常比myishex()更快。 （AF 或 af 的概率高于 0-9。）

---

但是从 FF 转换为二进制数字可能快比255慢。

int myhex2bin(string sz)
{
    int b = 0;

    sz = sz.substr(2); // Cut the "0x" out.

    for(size_t i = 0; i < sz.length(); ++i)
    {
        sz[i] = tolower(sz[i]);
        b += myhexdigit2dec(sz[i]) << ((sz.length() - (i + 1)) << 2);
    }

    return(b);
}

// Unsafe. Optimized for speed.
int myhexdigit2dec(char c)
{
    return(c < 'A' ? c - '0' : (c < 'a' ? c - 'A' + 10 : c - 'a' + 10));
}

虽然您不会得到十进制到二进制的位移，但也不会得到 AF 和 af 。

int mydec2bin(string sz)
{
    int b = 0;
    int factor = 1;

    for(size_t i = sz.length(); i > 0; --i)
    {
        b += (sz[i - 1] - '0') * factor;
        factor *= 10;
    }

    return(b);    
}

---

结论：仍取决于编译器，但 255 的编译速度可能更快。 :)