C++ 二进制常量/文字

Question

我正在使用一个众所周知的模板来允许二进制常量，

template< unsigned long long N >
struct binary
{
  enum { value = (N % 10) + 2 * binary< N / 10 > :: value } ;
};

template<>
struct binary< 0 >
{
  enum { value = 0 } ;
};

因此您可以执行类似“binary<101011011>::value”的操作。 不幸的是，无符号 long long 的长度限制为 20 位。

有人有更好的解决方案吗？

Answer 1

如果您的二进制值有一个前导零，这是否有效？ 前导零使常数成为八进制而不是十进制。

这导致了一种从该解决方案中挤出更多数字的方法 - 始终以零开始二进制常量！ 然后将模板中的 10 替换为 8。

Answer 2

我一直使用的方法，虽然不如你的那么优雅：

1/只使用十六进制。 一段时间后，您就会知道哪些十六进制数字代表哪些位模式。

2/ 使用常量并对它们进行“或”或“加”操作。 例如（可能需要对位模式进行限定符以使它们成为无符号或长整型）：

#define b0  0x00000001
#define b1  0x00000002
: : :
#define b31 0x80000000

unsigned long x = b2 | b7

3/ 如果性能并不重要且可读性很重要，则可以在运行时使用诸如“x = fromBin(”101011011 “）；”。

4/ 作为一个偷偷摸摸的解决方案，您可以编写一个预处理器来遍历 *.cppme 文件并通过将所有“0b101011011”类型字符串替换为其等效的“0x15b”字符串来创建 *.cpp 文件。 我不会轻易这样做，因为您可能需要担心各种棘手的语法组合。 但它允许您按照自己的意愿编写字符串，而不必担心编译器的变化无常，并且您可以通过仔细编码来限制语法的复杂性。

当然，下一步是修补 GCC 以识别“0b”常量，但这可能有点矫枉过正:-)

Answer 3

C++0x 有 用户定义的文字，可用于实现您正在谈论的内容。

不然我不知道如何改进这个模板。

Answer 4

template<unsigned int p,unsigned int i> struct BinaryDigit 
{
  enum  { value = p*2+i };
  typedef BinaryDigit<value,0> O;
  typedef BinaryDigit<value,1> I;
};
struct Bin
{
  typedef BinaryDigit<0,0> O;
  typedef BinaryDigit<0,1> I;
};

允许：

Bin::O::I::I::O::O::value

更加详细，但没有限制（当然，直到达到 unsigned int 的大小）。

Answer 5

您可以添加更多非类型模板参数来“模拟”其他位：

// Utility metafunction used by top_bit<N>.
template <unsigned long long N1, unsigned long long N2>
struct compare {
    enum { value = N1 > N2 ? N1 >> 1 : compare<N1 << 1, N2>::value };
};

// This is hit when N1 grows beyond the size representable
// in an unsigned long long.  It's value is never actually used.
template<unsigned long long N2>
struct compare<0, N2> {
    enum { value = 42 };
};

// Determine the highest 1-bit in an integer.  Returns 0 for N == 0.
template <unsigned long long N>
struct top_bit {
    enum { value = compare<1, N>::value };
};

template <unsigned long long N1, unsigned long long N2 = 0>
struct binary {
    enum {
        value =
            (top_bit<binary<N2>::value>::value << 1) * binary<N1>::value +
            binary<N2>::value
    };
};

template <unsigned long long N1>
struct binary<N1, 0> {
    enum { value = (N1 % 10) + 2 * binary<N1 / 10>::value };
};

template <>
struct binary<0> {
    enum { value = 0 } ;
};

您可以像以前一样使用它，例如：

binary<1001101>::value

但您也可以使用以下等效形式：

binary<100,1101>::value
binary<1001,101>::value
binary<100110,1>::value

基本上，额外的参数为您提供了另外 20 位可供使用。 如果需要，您可以添加更多参数。

因为第二个数字的位值用于计算第一个数字需要向左移动多远，所以第二个数字必须以 1 开头。（无论如何，这是必需的，因为以 0 开头会导致被解释为八进制数的数字。）

Answer 6

从技术上讲，它不是 C 也不是 C++，它是 GCC 特定的扩展，但 GCC 允许 二进制常量如此处所示：

 The following statements are identical:

 i =       42;
 i =     0x2a;
 i =      052;
 i = 0b101010;

希望有所帮助。 一些 Intel 编译器（我相信还有其他编译器）实现了一些 GNU 扩展。 也许你很幸运。

Answer 7

一个简单的 #define 效果很好：

#define HEX__(n) 0x##n##LU

#define B8__(x) ((x&0x0000000FLU)?1:0)\
               +((x&0x000000F0LU)?2:0)\
              +((x&0x00000F00LU)?4:0)\
               +((x&0x0000F000LU)?8:0)\
               +((x&0x000F0000LU)?16:0)\
               +((x&0x00F00000LU)?32:0)\
               +((x&0x0F000000LU)?64:0)\
               +((x&0xF0000000LU)?128:0)

#define B8(d) ((unsigned char)B8__(HEX__(d)))
#define B16(dmsb,dlsb) (((unsigned short)B8(dmsb)<<8) + B8(dlsb))
#define B32(dmsb,db2,db3,dlsb) (((unsigned long)B8(dmsb)<<24) + ((unsigned long)B8(db2)<<16) + ((unsigned long)B8(db3)<<8) + B8(dlsb))

B8(011100111)
B16(10011011,10011011)
B32(10011011,10011011,10011011,10011011)

不是我的发明，我很久以前在论坛上看到它。