是否有以二进制格式打印的 printf 转换器？

W

William Whyte

哈克但对我有用：

#define BYTE_TO_BINARY_PATTERN "%c%c%c%c%c%c%c%c"
#define BYTE_TO_BINARY(byte)  \
  (byte & 0x80 ? '1' : '0'), \
  (byte & 0x40 ? '1' : '0'), \
  (byte & 0x20 ? '1' : '0'), \
  (byte & 0x10 ? '1' : '0'), \
  (byte & 0x08 ? '1' : '0'), \
  (byte & 0x04 ? '1' : '0'), \
  (byte & 0x02 ? '1' : '0'), \
  (byte & 0x01 ? '1' : '0')

printf("Leading text "BYTE_TO_BINARY_PATTERN, BYTE_TO_BINARY(byte));

对于多字节类型

printf("m: "BYTE_TO_BINARY_PATTERN" "BYTE_TO_BINARY_PATTERN"\n",
  BYTE_TO_BINARY(m>>8), BYTE_TO_BINARY(m));

不幸的是，您需要所有额外的报价。这种方法存在宏的效率风险（不要将函数作为参数传递给 BYTE_TO_BINARY），但在此处的其他一些建议中避免了内存问题和 strcat 的多次调用。

并且具有在 printf 中可以多次调用的优点，而具有 static 缓冲区的那些则不能。

我冒昧地将 %d 更改为 %c，因为它应该更快（%d 必须执行 digit->char 转换，而 %c 只是输出参数

发布了此宏的扩展版本，支持 16、32、64 位 int：stackoverflow.com/a/25108449/432509

请注意，这种方法对堆栈不友好。假设 int 在系统上是 32 位，打印单个 32 位值将需要 32 * 4 字节值的空间；共 128 个字节。这取决于堆栈大小，可能是也可能不是问题。

在宏中的字节周围添加括号很重要，否则在发送操作 BYTE_TO_BINARY(a | b) -> a | 时可能会遇到问题。 b & 0x01 != (a | b) & 0x01

i

ib.

打印任何数据类型的二进制

// Assumes little endian
void printBits(size_t const size, void const * const ptr)
{
    unsigned char *b = (unsigned char*) ptr;
    unsigned char byte;
    int i, j;
    
    for (i = size-1; i >= 0; i--) {
        for (j = 7; j >= 0; j--) {
            byte = (b[i] >> j) & 1;
            printf("%u", byte);
        }
    }
    puts("");
}

测试：

int main(int argv, char* argc[])
{
    int i = 23;
    uint ui = UINT_MAX;
    float f = 23.45f;
    printBits(sizeof(i), &i);
    printBits(sizeof(ui), &ui);
    printBits(sizeof(f), &f);
    return 0;
}

建议 size_t i; for (i=size; i-- > 0; ) 以避免 size_t 与 int 不匹配。

有人可以详细说明这段代码背后的逻辑吗？

取 ptr 中的每个字节（外循环）；然后对于当前字节（内部循环）的每个位，用当前位（1 << j）屏蔽字节。右移得到一个包含 0 (0000 0000b) 或 1 (0000 0001b) 的字节。使用格式 %u 打印结果字节 printf。 HTH。

@ZX9 请注意，suggested code 使用 > 和 size_t 而不是您的评论的 >= 来确定何时终止循环。

@ZX9 仍然是您的有用原始评论，因为编码人员确实需要小心考虑使用无符号类型的 > 和 >= 的边缘情况。 0 是一个无符号的边缘情况并且经常发生，这与不太常见的 INT_MAX/INT_MIN 的有符号数学不同。

E

EvilTeach

这里有一个快速的技巧来演示做你想做的事情的技巧。

#include <stdio.h>      /* printf */
#include <string.h>     /* strcat */
#include <stdlib.h>     /* strtol */

const char *byte_to_binary
(
    int x
)
{
    static char b[9];
    b[0] = '\0';

    int z;
    for (z = 128; z > 0; z >>= 1)
    {
        strcat(b, ((x & z) == z) ? "1" : "0");
    }

    return b;
}

int main
(
    void
)
{
    {
        /* binary string to int */

        char *tmp;
        char *b = "0101";

        printf("%d\n", strtol(b, &tmp, 2));
    }

    {
        /* byte to binary string */

        printf("%s\n", byte_to_binary(5));
    }
    
    return 0;
}

这肯定比为 printf 编写转义重载更“奇怪”。对于刚接触代码的开发人员来说，这也很容易理解。

一些更改：strcat 是在每次循环时向字符串添加单个字符的低效方法。相反，添加一个 char *p = b; 并将内部循环替换为 *p++ = (x & z) ? '1' : '0'。 z 应该从 128 (2^7) 而不是 256 (2^8) 开始。考虑更新以获取要使用的缓冲区的指针（为了线程安全），类似于 inet_ntoa()。

@EvilTeach：您自己使用三元运算符作为 strcat() 的参数！我同意 strcat 可能比为赋值后递增取消引用的指针更容易理解，但即使是初学者也需要知道如何正确使用标准库。也许使用索引数组进行赋值会是一个很好的演示（并且实际上会起作用，因为每次调用函数时 b 都不会重置为全零）。

随机：二进制缓冲区 char 是静态的，并且在分配中被清零。这只会在第一次运行时清除它，之后它不会清除，而是使用最后一个值。

此外，这应该证明之前的结果在再次调用该函数后将无效，因此调用者不应尝试像这样使用它：printf("%s + %s = %s", byte_to_binary(3), byte_to_binary(4), byte_to_binary(3+4))。

D

DGentry

glibc 通常没有二进制转换说明符。

可以将自定义转换类型添加到 glibc 中的 printf() 系列函数。有关详细信息，请参阅 register_printf_function。您可以添加自定义 %b 转换供您自己使用，前提是它可以简化应用程序代码以使其可用。

这是关于如何在 glibc 中实现自定义 printf 格式的example。

warning: 'register_printf_function' is deprecated [-Wdeprecated-declarations] 不过有一个新函数可以做同样的事情：register_printf_specifier()。可在此处找到新用法示例：codereview.stackexchange.com/q/219994/200418

P

Peter Mortensen

您可以使用一张小桌子来提高速度1。类似的技术在嵌入式世界中很有用，例如，反转一个字节：

const char *bit_rep[16] = {
    [ 0] = "0000", [ 1] = "0001", [ 2] = "0010", [ 3] = "0011",
    [ 4] = "0100", [ 5] = "0101", [ 6] = "0110", [ 7] = "0111",
    [ 8] = "1000", [ 9] = "1001", [10] = "1010", [11] = "1011",
    [12] = "1100", [13] = "1101", [14] = "1110", [15] = "1111",
};

void print_byte(uint8_t byte)
{
    printf("%s%s", bit_rep[byte >> 4], bit_rep[byte & 0x0F]);
}

1 我主要指的是优化器不那么激进且速度差异明显的嵌入式应用程序。

有用！但是用于定义 bit_rep 的语法是什么？

这段代码看起来很棒。但是您将如何更新此代码以处理 uint16_t、uint32_t 和 uint64_t？

@Robk，4、8 和 16 个 %s 以及相同数量的 bit_rep[word >> 4K & 0xF..F] 参数应该可以。尽管我认为 64 位数字的 16 个字符串打印可能不会比循环 64 次并输出 0/1 快。

i

isrnick

打印最低有效位并将其移出右侧。这样做直到整数变为零打印二进制表示，不带前导零，但以相反的顺序。使用递归，可以很容易地更正顺序。

#include <stdio.h>

void print_binary(unsigned int number)
{
    if (number >> 1) {
        print_binary(number >> 1);
    }
    putc((number & 1) ? '1' : '0', stdout);
}

对我来说，这是解决问题的最干净的方法之一。如果您喜欢 0b 前缀和尾随换行符，我建议包装该函数。

Online demo

您还应该使用 unsigned int 数字，因为当给定数字为负数时，该函数进入一个永无止境的递归调用。

更有效的方法，因为在 ASCII 中，'0'+1='1': putc('0'+(number&1), stdout);

我已将函数更改为也可以使用等于或小于 0 的 int 值。

将以下值 0x80 传递给您的函数，结果与预期不符。

i

ideasman42

根据@William Whyte 的回答，这是一个提供 int8、16、32 和64 版本，重复使用 INT8 宏以避免重复。

/* --- PRINTF_BYTE_TO_BINARY macro's --- */
#define PRINTF_BINARY_PATTERN_INT8 "%c%c%c%c%c%c%c%c"
#define PRINTF_BYTE_TO_BINARY_INT8(i)    \
    (((i) & 0x80ll) ? '1' : '0'), \
    (((i) & 0x40ll) ? '1' : '0'), \
    (((i) & 0x20ll) ? '1' : '0'), \
    (((i) & 0x10ll) ? '1' : '0'), \
    (((i) & 0x08ll) ? '1' : '0'), \
    (((i) & 0x04ll) ? '1' : '0'), \
    (((i) & 0x02ll) ? '1' : '0'), \
    (((i) & 0x01ll) ? '1' : '0')

#define PRINTF_BINARY_PATTERN_INT16 \
    PRINTF_BINARY_PATTERN_INT8              PRINTF_BINARY_PATTERN_INT8
#define PRINTF_BYTE_TO_BINARY_INT16(i) \
    PRINTF_BYTE_TO_BINARY_INT8((i) >> 8),   PRINTF_BYTE_TO_BINARY_INT8(i)
#define PRINTF_BINARY_PATTERN_INT32 \
    PRINTF_BINARY_PATTERN_INT16             PRINTF_BINARY_PATTERN_INT16
#define PRINTF_BYTE_TO_BINARY_INT32(i) \
    PRINTF_BYTE_TO_BINARY_INT16((i) >> 16), PRINTF_BYTE_TO_BINARY_INT16(i)
#define PRINTF_BINARY_PATTERN_INT64    \
    PRINTF_BINARY_PATTERN_INT32             PRINTF_BINARY_PATTERN_INT32
#define PRINTF_BYTE_TO_BINARY_INT64(i) \
    PRINTF_BYTE_TO_BINARY_INT32((i) >> 32), PRINTF_BYTE_TO_BINARY_INT32(i)
/* --- end macros --- */

#include <stdio.h>
int main() {
    long long int flag = 1648646756487983144ll;
    printf("My Flag "
           PRINTF_BINARY_PATTERN_INT64 "\n",
           PRINTF_BYTE_TO_BINARY_INT64(flag));
    return 0;
}

这输出：

My Flag 0001011011100001001010110111110101111000100100001111000000101000

为了便于阅读，您可能需要添加一个分隔符，例如：

My Flag 00010110,11100001,00101011,01111101,01111000,10010000,11110000,00101000

这是极好的。打印以最低有效位开头的位是否有特殊原因？

您如何建议添加逗号？

将添加 PRINTF_BYTE_TO_BINARY_INT# 定义的分组版本以供选择使用。

i

ib.

这是一个不受可重入问题或参数大小/类型限制的函数版本：

#define FMT_BUF_SIZE (CHAR_BIT*sizeof(uintmax_t)+1)

char *binary_fmt(uintmax_t x, char buf[static FMT_BUF_SIZE])
{
    char *s = buf + FMT_BUF_SIZE;
    *--s = 0;
    if (!x) *--s = '0';
    for (; x; x /= 2) *--s = '0' + x%2;
    return s;
}

请注意，如果您只需将 2 替换为所需的基数，则此代码对于 2 到 10 之间的任何基数都同样有效。用法是：

char tmp[FMT_BUF_SIZE];
printf("%s\n", binary_fmt(x, tmp));

其中 x 是任何整数表达式。

是的，你可以做到这一点。但这确实是糟糕的设计。即使您没有线程或重入，调用者也必须知道静态缓冲区正在被重用，并且 char *a = binary_fmt(x), *b = binary_fmt(y); 之类的东西不会按预期工作。强制调用者传递一个缓冲区使得存储需求明确；如果确实需要，调用者当然可以自由使用静态缓冲区，然后对同一缓冲区的重用变得明确。另请注意，在现代 PIC ABI 上，静态缓冲区通常比堆栈上的缓冲区花费更多的代码来访问。

这仍然是一个糟糕的设计。在这些情况下，它需要一个额外的复制步骤，而且即使在不需要复制的情况下，它也不比让调用者提供缓冲区便宜。使用静态存储只是一个坏习惯。

必须使用不必要的额外名称污染预处理器或变量符号表的名称空间，该名称必须用于正确调整每个调用者必须分配的存储空间，并强制每个调用者知道该值并分配必要数量的当更简单的函数本地存储解决方案足以满足大多数意图和目的，并且当一个简单的 strdup() 调用涵盖其余 99% 的用途时，存储是糟糕的设计。

在这里，我们将不得不不同意。我看不出添加一个不显眼的预处理器符号是如何接近严重限制使用案例的有害性，使接口容易出错，在程序期间为临时值保留永久存储，并在大多数情况下生成更糟糕的代码现代平台。

我不提倡无缘无故地进行微优化（即测量）。但我确实认为性能，即使它是在微增益范围内，当它作为一种奖励以及从根本上优越的设计时，也值得一提。

R

Robotbugs

快速简便的解决方案：

void printbits(my_integer_type x)
{
    for(int i=sizeof(x)<<3; i; i--)
        putchar('0'+((x>>(i-1))&1));
}

适用于任何大小类型以及有符号和无符号整数。需要 '&1' 来处理有符号整数，因为移位可能会进行符号扩展。

有很多方法可以做到这一点。这是一个超级简单的方法，用于从有符号或无符号 32 位类型打印 32 位或 n 位（如果有符号则不放置负数，只打印实际位）并且没有回车。请注意， i 在位移之前递减：

#define printbits_n(x,n) for (int i=n;i;i--,putchar('0'|(x>>i)&1))
#define printbits_32(x) printbits_n(x,32)

返回一个带有位的字符串以供以后存储或打印怎么样？您可以分配内存并返回它，用户必须释放它，或者您返回一个静态字符串，但如果再次调用它或被另一个线程调用，它将被破坏。两种方法都显示：

char *int_to_bitstring_alloc(int x, int count)
{
    count = count<1 ? sizeof(x)*8 : count;
    char *pstr = malloc(count+1);
    for(int i = 0; i<count; i++)
        pstr[i] = '0' | ((x>>(count-1-i))&1);
    pstr[count]=0;
    return pstr;
}

#define BITSIZEOF(x)    (sizeof(x)*8)

char *int_to_bitstring_static(int x, int count)
{
    static char bitbuf[BITSIZEOF(x)+1];
    count = (count<1 || count>BITSIZEOF(x)) ? BITSIZEOF(x) : count;
    for(int i = 0; i<count; i++)
        bitbuf[i] = '0' | ((x>>(count-1-i))&1);
    bitbuf[count]=0;
    return bitbuf;
}

致电：

// memory allocated string returned which needs to be freed
char *pstr = int_to_bitstring_alloc(0x97e50ae6, 17);
printf("bits = 0b%s\n", pstr);
free(pstr);

// no free needed but you need to copy the string to save it somewhere else
char *pstr2 = int_to_bitstring_static(0x97e50ae6, 17);
printf("bits = 0b%s\n", pstr2);

我正在对此进行测试，看起来这两种 *int_to_bitstring_ 方法都无法正确计算结果，还是我遗漏了什么？ printbits 工作正常。此外，对于大于 32 的小数，静态和分配方法的结果开始不同。在 C 和使用位方面没有太多经验。

i

ib.

const char* byte_to_binary(int x)
{
    static char b[sizeof(int)*8+1] = {0};
    int y;
    long long z;

    for (z = 1LL<<sizeof(int)*8-1, y = 0; z > 0; z >>= 1, y++) {
        b[y] = (((x & z) == z) ? '1' : '0');
    }
    b[y] = 0;

    return b;
}

很好的解决方案。不过我会改变一些东西。即在字符串中向后移动，以便可以正确处理任何大小的输入。

所有这些 8 都应替换为 CHAR_BIT。

我喜欢那个 id 不使用任何类型的字符串库，因此可以很容易地在嵌入设置中使用

使用静态变量对于这个函数来说真的很糟糕。想象一下 printf(byte_to_binary(1), byte_to_binary(5))，其中一个调用会覆盖来自另一个调用的字符串